#pragma once

#include <chrono>
#include "can_parser.h"
#include "proto2json.h"
#include "can_param.h"
#include "can2proto.h"
#include "log.h"


namespace {

uint64_t GetTimeStamp() {
  auto time_now = std::chrono::system_clock::now();
  auto time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
      time_now.time_since_epoch());
  return static_cast<uint64_t>(time_ms.count());
}

}  // namespace    
struct AVM_APA_1_Parser {
    SignalParser APA_EPS_Control_Request;

    SignalParser AVM_APA_1_HzrdLiReq;

    SignalParser AVM_APA_SystemSts;

    SignalParser APA_Active;

    SignalParser APAFailureSts;

    SignalParser ReasonForDVDnotDisplyAPA;

    SignalParser APA_SteeringWheelAngleReq;

    SignalParser TarSpd;

    SignalParser AVM_APA_1_AliveCounter;

    SignalParser AVM_APA_1_CRC;

    AVM_APA_1_Parser() {
        APA_EPS_Control_Request = CanConfiguration::Instance().SignalParsers()["APA_EPS_Control_Request"];
        AVM_APA_1_HzrdLiReq = CanConfiguration::Instance().SignalParsers()["AVM_APA_1_HzrdLiReq"];
        AVM_APA_SystemSts = CanConfiguration::Instance().SignalParsers()["AVM_APA_SystemSts"];
        APA_Active = CanConfiguration::Instance().SignalParsers()["APA_Active"];
        APAFailureSts = CanConfiguration::Instance().SignalParsers()["APAFailureSts"];
        ReasonForDVDnotDisplyAPA = CanConfiguration::Instance().SignalParsers()["ReasonForDVDnotDisplyAPA"];
        APA_SteeringWheelAngleReq = CanConfiguration::Instance().SignalParsers()["APA_SteeringWheelAngleReq"];
        TarSpd = CanConfiguration::Instance().SignalParsers()["TarSpd"];
        AVM_APA_1_AliveCounter = CanConfiguration::Instance().SignalParsers()["AVM_APA_1_AliveCounter"];
        AVM_APA_1_CRC = CanConfiguration::Instance().SignalParsers()["AVM_APA_1_CRC"];
    }

    void Parser(uint8_t* payload){
        APA_EPS_Control_Request.Parser(payload);
        AVM_APA_1_HzrdLiReq.Parser(payload);
        AVM_APA_SystemSts.Parser(payload);
        APA_Active.Parser(payload);
        APAFailureSts.Parser(payload);
        ReasonForDVDnotDisplyAPA.Parser(payload);
        APA_SteeringWheelAngleReq.Parser(payload);
        TarSpd.Parser(payload);
        AVM_APA_1_AliveCounter.Parser(payload);
        AVM_APA_1_CRC.Parser(payload);
    }

    void CanParser2CanStruct_AVM_APA_1_MSG(AVM_APA_1_MSG& msg) {
        double factor;
        double offset;
        factor = APA_EPS_Control_Request.factor;
        offset = APA_EPS_Control_Request.offset;
        msg.APA_EPS_Control_Request = *reinterpret_cast<std::decay<decltype(msg.APA_EPS_Control_Request)>::type*>(&APA_EPS_Control_Request.signal);
        msg.APA_EPS_Control_Request = msg.APA_EPS_Control_Request * factor + offset;
        factor = AVM_APA_1_HzrdLiReq.factor;
        offset = AVM_APA_1_HzrdLiReq.offset;
        msg.AVM_APA_1_HzrdLiReq = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_1_HzrdLiReq)>::type*>(&AVM_APA_1_HzrdLiReq.signal);
        msg.AVM_APA_1_HzrdLiReq = msg.AVM_APA_1_HzrdLiReq * factor + offset;
        factor = AVM_APA_SystemSts.factor;
        offset = AVM_APA_SystemSts.offset;
        msg.AVM_APA_SystemSts = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_SystemSts)>::type*>(&AVM_APA_SystemSts.signal);
        msg.AVM_APA_SystemSts = msg.AVM_APA_SystemSts * factor + offset;
        factor = APA_Active.factor;
        offset = APA_Active.offset;
        msg.APA_Active = *reinterpret_cast<std::decay<decltype(msg.APA_Active)>::type*>(&APA_Active.signal);
        msg.APA_Active = msg.APA_Active * factor + offset;
        factor = APAFailureSts.factor;
        offset = APAFailureSts.offset;
        msg.APAFailureSts = *reinterpret_cast<std::decay<decltype(msg.APAFailureSts)>::type*>(&APAFailureSts.signal);
        msg.APAFailureSts = msg.APAFailureSts * factor + offset;
        factor = ReasonForDVDnotDisplyAPA.factor;
        offset = ReasonForDVDnotDisplyAPA.offset;
        msg.ReasonForDVDnotDisplyAPA = *reinterpret_cast<std::decay<decltype(msg.ReasonForDVDnotDisplyAPA)>::type*>(&ReasonForDVDnotDisplyAPA.signal);
        msg.ReasonForDVDnotDisplyAPA = msg.ReasonForDVDnotDisplyAPA * factor + offset;
        factor = APA_SteeringWheelAngleReq.factor;
        offset = APA_SteeringWheelAngleReq.offset;
        msg.APA_SteeringWheelAngleReq = *reinterpret_cast<std::decay<decltype(msg.APA_SteeringWheelAngleReq)>::type*>(&APA_SteeringWheelAngleReq.signal);
        msg.APA_SteeringWheelAngleReq = msg.APA_SteeringWheelAngleReq * factor + offset;
        factor = TarSpd.factor;
        offset = TarSpd.offset;
        msg.TarSpd = *reinterpret_cast<std::decay<decltype(msg.TarSpd)>::type*>(&TarSpd.signal);
        msg.TarSpd = msg.TarSpd * factor + offset;
        factor = AVM_APA_1_AliveCounter.factor;
        offset = AVM_APA_1_AliveCounter.offset;
        msg.AVM_APA_1_AliveCounter = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_1_AliveCounter)>::type*>(&AVM_APA_1_AliveCounter.signal);
        msg.AVM_APA_1_AliveCounter = msg.AVM_APA_1_AliveCounter * factor + offset;
        factor = AVM_APA_1_CRC.factor;
        offset = AVM_APA_1_CRC.offset;
        msg.AVM_APA_1_CRC = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_1_CRC)>::type*>(&AVM_APA_1_CRC.signal);
        msg.AVM_APA_1_CRC = msg.AVM_APA_1_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        AVM_APA_1_MSG can_struct;
        CanParser2CanStruct_AVM_APA_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::AVM_APA_1_MSGMsg>();
        Struct2Proto_AVM_APA_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("avm_apa_1") != nullptr) {
            DFHLOG_I("avm_apa_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("avm_apa_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port avm_apa_1");
            return false;
         }
    }
};

struct AVM_APA_2_Parser {
    SignalParser APA_ESP_Stop_Distance;

    SignalParser APA_ESP_Speed_Limitation;

    SignalParser APA_Allow_ESP_Control_Brake;

    SignalParser APA_ESP_Control_Request;

    SignalParser APA_ESP_Target_Gear_Request;

    SignalParser APA_FailureBrakeMode;

    SignalParser AVM_APA_2_APAEPBCtrlReq;

    SignalParser AVM_APA_2_Reserved1;

    SignalParser AVM_APA_2_AliveCounter;

    SignalParser AVM_APA_2_CRC;

    AVM_APA_2_Parser() {
        APA_ESP_Stop_Distance = CanConfiguration::Instance().SignalParsers()["APA_ESP_Stop_Distance"];
        APA_ESP_Speed_Limitation = CanConfiguration::Instance().SignalParsers()["APA_ESP_Speed_Limitation"];
        APA_Allow_ESP_Control_Brake = CanConfiguration::Instance().SignalParsers()["APA_Allow_ESP_Control_Brake"];
        APA_ESP_Control_Request = CanConfiguration::Instance().SignalParsers()["APA_ESP_Control_Request"];
        APA_ESP_Target_Gear_Request = CanConfiguration::Instance().SignalParsers()["APA_ESP_Target_Gear_Request"];
        APA_FailureBrakeMode = CanConfiguration::Instance().SignalParsers()["APA_FailureBrakeMode"];
        AVM_APA_2_APAEPBCtrlReq = CanConfiguration::Instance().SignalParsers()["AVM_APA_2_APAEPBCtrlReq"];
        AVM_APA_2_Reserved1 = CanConfiguration::Instance().SignalParsers()["AVM_APA_2_Reserved1"];
        AVM_APA_2_AliveCounter = CanConfiguration::Instance().SignalParsers()["AVM_APA_2_AliveCounter"];
        AVM_APA_2_CRC = CanConfiguration::Instance().SignalParsers()["AVM_APA_2_CRC"];
    }

    void Parser(uint8_t* payload){
        APA_ESP_Stop_Distance.Parser(payload);
        APA_ESP_Speed_Limitation.Parser(payload);
        APA_Allow_ESP_Control_Brake.Parser(payload);
        APA_ESP_Control_Request.Parser(payload);
        APA_ESP_Target_Gear_Request.Parser(payload);
        APA_FailureBrakeMode.Parser(payload);
        AVM_APA_2_APAEPBCtrlReq.Parser(payload);
        AVM_APA_2_Reserved1.Parser(payload);
        AVM_APA_2_AliveCounter.Parser(payload);
        AVM_APA_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_AVM_APA_2_MSG(AVM_APA_2_MSG& msg) {
        double factor;
        double offset;
        factor = APA_ESP_Stop_Distance.factor;
        offset = APA_ESP_Stop_Distance.offset;
        msg.APA_ESP_Stop_Distance = *reinterpret_cast<std::decay<decltype(msg.APA_ESP_Stop_Distance)>::type*>(&APA_ESP_Stop_Distance.signal);
        msg.APA_ESP_Stop_Distance = msg.APA_ESP_Stop_Distance * factor + offset;
        factor = APA_ESP_Speed_Limitation.factor;
        offset = APA_ESP_Speed_Limitation.offset;
        msg.APA_ESP_Speed_Limitation = *reinterpret_cast<std::decay<decltype(msg.APA_ESP_Speed_Limitation)>::type*>(&APA_ESP_Speed_Limitation.signal);
        msg.APA_ESP_Speed_Limitation = msg.APA_ESP_Speed_Limitation * factor + offset;
        factor = APA_Allow_ESP_Control_Brake.factor;
        offset = APA_Allow_ESP_Control_Brake.offset;
        msg.APA_Allow_ESP_Control_Brake = *reinterpret_cast<std::decay<decltype(msg.APA_Allow_ESP_Control_Brake)>::type*>(&APA_Allow_ESP_Control_Brake.signal);
        msg.APA_Allow_ESP_Control_Brake = msg.APA_Allow_ESP_Control_Brake * factor + offset;
        factor = APA_ESP_Control_Request.factor;
        offset = APA_ESP_Control_Request.offset;
        msg.APA_ESP_Control_Request = *reinterpret_cast<std::decay<decltype(msg.APA_ESP_Control_Request)>::type*>(&APA_ESP_Control_Request.signal);
        msg.APA_ESP_Control_Request = msg.APA_ESP_Control_Request * factor + offset;
        factor = APA_ESP_Target_Gear_Request.factor;
        offset = APA_ESP_Target_Gear_Request.offset;
        msg.APA_ESP_Target_Gear_Request = *reinterpret_cast<std::decay<decltype(msg.APA_ESP_Target_Gear_Request)>::type*>(&APA_ESP_Target_Gear_Request.signal);
        msg.APA_ESP_Target_Gear_Request = msg.APA_ESP_Target_Gear_Request * factor + offset;
        factor = APA_FailureBrakeMode.factor;
        offset = APA_FailureBrakeMode.offset;
        msg.APA_FailureBrakeMode = *reinterpret_cast<std::decay<decltype(msg.APA_FailureBrakeMode)>::type*>(&APA_FailureBrakeMode.signal);
        msg.APA_FailureBrakeMode = msg.APA_FailureBrakeMode * factor + offset;
        factor = AVM_APA_2_APAEPBCtrlReq.factor;
        offset = AVM_APA_2_APAEPBCtrlReq.offset;
        msg.AVM_APA_2_APAEPBCtrlReq = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_2_APAEPBCtrlReq)>::type*>(&AVM_APA_2_APAEPBCtrlReq.signal);
        msg.AVM_APA_2_APAEPBCtrlReq = msg.AVM_APA_2_APAEPBCtrlReq * factor + offset;
        factor = AVM_APA_2_Reserved1.factor;
        offset = AVM_APA_2_Reserved1.offset;
        msg.AVM_APA_2_Reserved1 = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_2_Reserved1)>::type*>(&AVM_APA_2_Reserved1.signal);
        msg.AVM_APA_2_Reserved1 = msg.AVM_APA_2_Reserved1 * factor + offset;
        factor = AVM_APA_2_AliveCounter.factor;
        offset = AVM_APA_2_AliveCounter.offset;
        msg.AVM_APA_2_AliveCounter = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_2_AliveCounter)>::type*>(&AVM_APA_2_AliveCounter.signal);
        msg.AVM_APA_2_AliveCounter = msg.AVM_APA_2_AliveCounter * factor + offset;
        factor = AVM_APA_2_CRC.factor;
        offset = AVM_APA_2_CRC.offset;
        msg.AVM_APA_2_CRC = *reinterpret_cast<std::decay<decltype(msg.AVM_APA_2_CRC)>::type*>(&AVM_APA_2_CRC.signal);
        msg.AVM_APA_2_CRC = msg.AVM_APA_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        AVM_APA_2_MSG can_struct;
        CanParser2CanStruct_AVM_APA_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::AVM_APA_2_MSGMsg>();
        Struct2Proto_AVM_APA_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("avm_apa_2") != nullptr) {
            DFHLOG_I("avm_apa_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("avm_apa_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port avm_apa_2");
            return false;
         }
    }
};

struct FCM_2_Parser {
    SignalParser HMA_Status;

    SignalParser HMA_HighbeamReq;

    SignalParser LDW_ELK_TJA_LDPLeftVisuali;

    SignalParser LDW_ELK_TJA_LDPRightVisuali;

    SignalParser SLAState;

    SignalParser SLASpdlimit;

    SignalParser SLASpdlimitWarning;

    SignalParser Camera_textinfo;

    SignalParser FCM_2_SLASpdlimitUnits;

    SignalParser FCM_2_MessageCounter;

    SignalParser FCM_2_CRC;

    FCM_2_Parser() {
        HMA_Status = CanConfiguration::Instance().SignalParsers()["HMA_Status"];
        HMA_HighbeamReq = CanConfiguration::Instance().SignalParsers()["HMA_HighbeamReq"];
        LDW_ELK_TJA_LDPLeftVisuali = CanConfiguration::Instance().SignalParsers()["LDW_ELK_TJA_LDPLeftVisuali"];
        LDW_ELK_TJA_LDPRightVisuali = CanConfiguration::Instance().SignalParsers()["LDW_ELK_TJA_LDPRightVisuali"];
        SLAState = CanConfiguration::Instance().SignalParsers()["SLAState"];
        SLASpdlimit = CanConfiguration::Instance().SignalParsers()["SLASpdlimit"];
        SLASpdlimitWarning = CanConfiguration::Instance().SignalParsers()["SLASpdlimitWarning"];
        Camera_textinfo = CanConfiguration::Instance().SignalParsers()["Camera_textinfo"];
        FCM_2_SLASpdlimitUnits = CanConfiguration::Instance().SignalParsers()["FCM_2_SLASpdlimitUnits"];
        FCM_2_MessageCounter = CanConfiguration::Instance().SignalParsers()["FCM_2_MessageCounter"];
        FCM_2_CRC = CanConfiguration::Instance().SignalParsers()["FCM_2_CRC"];
    }

    void Parser(uint8_t* payload){
        HMA_Status.Parser(payload);
        HMA_HighbeamReq.Parser(payload);
        LDW_ELK_TJA_LDPLeftVisuali.Parser(payload);
        LDW_ELK_TJA_LDPRightVisuali.Parser(payload);
        SLAState.Parser(payload);
        SLASpdlimit.Parser(payload);
        SLASpdlimitWarning.Parser(payload);
        Camera_textinfo.Parser(payload);
        FCM_2_SLASpdlimitUnits.Parser(payload);
        FCM_2_MessageCounter.Parser(payload);
        FCM_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_2_MSG(FCM_2_MSG& msg) {
        double factor;
        double offset;
        factor = HMA_Status.factor;
        offset = HMA_Status.offset;
        msg.HMA_Status = *reinterpret_cast<std::decay<decltype(msg.HMA_Status)>::type*>(&HMA_Status.signal);
        msg.HMA_Status = msg.HMA_Status * factor + offset;
        factor = HMA_HighbeamReq.factor;
        offset = HMA_HighbeamReq.offset;
        msg.HMA_HighbeamReq = *reinterpret_cast<std::decay<decltype(msg.HMA_HighbeamReq)>::type*>(&HMA_HighbeamReq.signal);
        msg.HMA_HighbeamReq = msg.HMA_HighbeamReq * factor + offset;
        factor = LDW_ELK_TJA_LDPLeftVisuali.factor;
        offset = LDW_ELK_TJA_LDPLeftVisuali.offset;
        msg.LDW_ELK_TJA_LDPLeftVisuali = *reinterpret_cast<std::decay<decltype(msg.LDW_ELK_TJA_LDPLeftVisuali)>::type*>(&LDW_ELK_TJA_LDPLeftVisuali.signal);
        msg.LDW_ELK_TJA_LDPLeftVisuali = msg.LDW_ELK_TJA_LDPLeftVisuali * factor + offset;
        factor = LDW_ELK_TJA_LDPRightVisuali.factor;
        offset = LDW_ELK_TJA_LDPRightVisuali.offset;
        msg.LDW_ELK_TJA_LDPRightVisuali = *reinterpret_cast<std::decay<decltype(msg.LDW_ELK_TJA_LDPRightVisuali)>::type*>(&LDW_ELK_TJA_LDPRightVisuali.signal);
        msg.LDW_ELK_TJA_LDPRightVisuali = msg.LDW_ELK_TJA_LDPRightVisuali * factor + offset;
        factor = SLAState.factor;
        offset = SLAState.offset;
        msg.SLAState = *reinterpret_cast<std::decay<decltype(msg.SLAState)>::type*>(&SLAState.signal);
        msg.SLAState = msg.SLAState * factor + offset;
        factor = SLASpdlimit.factor;
        offset = SLASpdlimit.offset;
        msg.SLASpdlimit = *reinterpret_cast<std::decay<decltype(msg.SLASpdlimit)>::type*>(&SLASpdlimit.signal);
        msg.SLASpdlimit = msg.SLASpdlimit * factor + offset;
        factor = SLASpdlimitWarning.factor;
        offset = SLASpdlimitWarning.offset;
        msg.SLASpdlimitWarning = *reinterpret_cast<std::decay<decltype(msg.SLASpdlimitWarning)>::type*>(&SLASpdlimitWarning.signal);
        msg.SLASpdlimitWarning = msg.SLASpdlimitWarning * factor + offset;
        factor = Camera_textinfo.factor;
        offset = Camera_textinfo.offset;
        msg.Camera_textinfo = *reinterpret_cast<std::decay<decltype(msg.Camera_textinfo)>::type*>(&Camera_textinfo.signal);
        msg.Camera_textinfo = msg.Camera_textinfo * factor + offset;
        factor = FCM_2_SLASpdlimitUnits.factor;
        offset = FCM_2_SLASpdlimitUnits.offset;
        msg.FCM_2_SLASpdlimitUnits = *reinterpret_cast<std::decay<decltype(msg.FCM_2_SLASpdlimitUnits)>::type*>(&FCM_2_SLASpdlimitUnits.signal);
        msg.FCM_2_SLASpdlimitUnits = msg.FCM_2_SLASpdlimitUnits * factor + offset;
        factor = FCM_2_MessageCounter.factor;
        offset = FCM_2_MessageCounter.offset;
        msg.FCM_2_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.FCM_2_MessageCounter)>::type*>(&FCM_2_MessageCounter.signal);
        msg.FCM_2_MessageCounter = msg.FCM_2_MessageCounter * factor + offset;
        factor = FCM_2_CRC.factor;
        offset = FCM_2_CRC.offset;
        msg.FCM_2_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_2_CRC)>::type*>(&FCM_2_CRC.signal);
        msg.FCM_2_CRC = msg.FCM_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_2_MSG can_struct;
        CanParser2CanStruct_FCM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_2_MSGMsg>();
        Struct2Proto_FCM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_2") != nullptr) {
            DFHLOG_I("fcm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_2");
            return false;
         }
    }
};

struct FCM_3_Parser {
    SignalParser FCM_3_StrngWhlAgReq;

    SignalParser FCM_3_StrngWhlAgReqActive;

    SignalParser FCM_3_HptcVibReq;

    SignalParser FCM_3_AngCtrlTrqUpprLim;

    SignalParser FCM_3_AngCtrlTrqLowrLim;

    SignalParser FCM_3_ManMachineSharingSts;

    SignalParser FCM_3_MsgCntr;

    SignalParser FCM_3_CRC;

    FCM_3_Parser() {
        FCM_3_StrngWhlAgReq = CanConfiguration::Instance().SignalParsers()["FCM_3_StrngWhlAgReq"];
        FCM_3_StrngWhlAgReqActive = CanConfiguration::Instance().SignalParsers()["FCM_3_StrngWhlAgReqActive"];
        FCM_3_HptcVibReq = CanConfiguration::Instance().SignalParsers()["FCM_3_HptcVibReq"];
        FCM_3_AngCtrlTrqUpprLim = CanConfiguration::Instance().SignalParsers()["FCM_3_AngCtrlTrqUpprLim"];
        FCM_3_AngCtrlTrqLowrLim = CanConfiguration::Instance().SignalParsers()["FCM_3_AngCtrlTrqLowrLim"];
        FCM_3_ManMachineSharingSts = CanConfiguration::Instance().SignalParsers()["FCM_3_ManMachineSharingSts"];
        FCM_3_MsgCntr = CanConfiguration::Instance().SignalParsers()["FCM_3_MsgCntr"];
        FCM_3_CRC = CanConfiguration::Instance().SignalParsers()["FCM_3_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_3_StrngWhlAgReq.Parser(payload);
        FCM_3_StrngWhlAgReqActive.Parser(payload);
        FCM_3_HptcVibReq.Parser(payload);
        FCM_3_AngCtrlTrqUpprLim.Parser(payload);
        FCM_3_AngCtrlTrqLowrLim.Parser(payload);
        FCM_3_ManMachineSharingSts.Parser(payload);
        FCM_3_MsgCntr.Parser(payload);
        FCM_3_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_3_MSG(FCM_3_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_3_StrngWhlAgReq.factor;
        offset = FCM_3_StrngWhlAgReq.offset;
        msg.FCM_3_StrngWhlAgReq = *reinterpret_cast<std::decay<decltype(msg.FCM_3_StrngWhlAgReq)>::type*>(&FCM_3_StrngWhlAgReq.signal);
        msg.FCM_3_StrngWhlAgReq = msg.FCM_3_StrngWhlAgReq * factor + offset;
        factor = FCM_3_StrngWhlAgReqActive.factor;
        offset = FCM_3_StrngWhlAgReqActive.offset;
        msg.FCM_3_StrngWhlAgReqActive = *reinterpret_cast<std::decay<decltype(msg.FCM_3_StrngWhlAgReqActive)>::type*>(&FCM_3_StrngWhlAgReqActive.signal);
        msg.FCM_3_StrngWhlAgReqActive = msg.FCM_3_StrngWhlAgReqActive * factor + offset;
        factor = FCM_3_HptcVibReq.factor;
        offset = FCM_3_HptcVibReq.offset;
        msg.FCM_3_HptcVibReq = *reinterpret_cast<std::decay<decltype(msg.FCM_3_HptcVibReq)>::type*>(&FCM_3_HptcVibReq.signal);
        msg.FCM_3_HptcVibReq = msg.FCM_3_HptcVibReq * factor + offset;
        factor = FCM_3_AngCtrlTrqUpprLim.factor;
        offset = FCM_3_AngCtrlTrqUpprLim.offset;
        msg.FCM_3_AngCtrlTrqUpprLim = *reinterpret_cast<std::decay<decltype(msg.FCM_3_AngCtrlTrqUpprLim)>::type*>(&FCM_3_AngCtrlTrqUpprLim.signal);
        msg.FCM_3_AngCtrlTrqUpprLim = msg.FCM_3_AngCtrlTrqUpprLim * factor + offset;
        factor = FCM_3_AngCtrlTrqLowrLim.factor;
        offset = FCM_3_AngCtrlTrqLowrLim.offset;
        msg.FCM_3_AngCtrlTrqLowrLim = *reinterpret_cast<std::decay<decltype(msg.FCM_3_AngCtrlTrqLowrLim)>::type*>(&FCM_3_AngCtrlTrqLowrLim.signal);
        msg.FCM_3_AngCtrlTrqLowrLim = msg.FCM_3_AngCtrlTrqLowrLim * factor + offset;
        factor = FCM_3_ManMachineSharingSts.factor;
        offset = FCM_3_ManMachineSharingSts.offset;
        msg.FCM_3_ManMachineSharingSts = *reinterpret_cast<std::decay<decltype(msg.FCM_3_ManMachineSharingSts)>::type*>(&FCM_3_ManMachineSharingSts.signal);
        msg.FCM_3_ManMachineSharingSts = msg.FCM_3_ManMachineSharingSts * factor + offset;
        factor = FCM_3_MsgCntr.factor;
        offset = FCM_3_MsgCntr.offset;
        msg.FCM_3_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.FCM_3_MsgCntr)>::type*>(&FCM_3_MsgCntr.signal);
        msg.FCM_3_MsgCntr = msg.FCM_3_MsgCntr * factor + offset;
        factor = FCM_3_CRC.factor;
        offset = FCM_3_CRC.offset;
        msg.FCM_3_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_3_CRC)>::type*>(&FCM_3_CRC.signal);
        msg.FCM_3_CRC = msg.FCM_3_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_3_MSG can_struct;
        CanParser2CanStruct_FCM_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_3_MSGMsg>();
        Struct2Proto_FCM_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_3") != nullptr) {
            DFHLOG_I("fcm_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_3");
            return false;
         }
    }
};

struct FCM_5_Parser {
    SignalParser FCM_5_TJAICAExitTextInfoSts;

    SignalParser FCM_5_SLAONOFFSts;

    SignalParser FCM_5_IESONOFFSts;

    SignalParser FCM_5_HMAONOFFSts;

    SignalParser FCM_5_TSIONOFFSts;

    SignalParser FCM_5_TLIONOFFSts;

    SignalParser FCM_5_LDWONOFFSts;

    SignalParser FCM_5_WarnModSts;

    SignalParser FCM_5_LDPONOFFSts;

    SignalParser FCM_5_LDWLDPSnvtySts;

    SignalParser FCM_5_ELKONOFFSts;

    SignalParser SLWFONOFFSts;

    SignalParser SLASpdlimitWarningAudSWSts;

    SignalParser FCM_5_SpeedLmtNmberAb;

    SignalParser FCM_5_SpeedLmtNmberE;

    SignalParser FCM_5_SLAmodeSWSet;

    SignalParser FCM_5_Resd_1;

    SignalParser FCM_5_MsgCntr;

    SignalParser FCM_5_CRC;

    FCM_5_Parser() {
        FCM_5_TJAICAExitTextInfoSts = CanConfiguration::Instance().SignalParsers()["FCM_5_TJAICAExitTextInfoSts"];
        FCM_5_SLAONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_SLAONOFFSts"];
        FCM_5_IESONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_IESONOFFSts"];
        FCM_5_HMAONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_HMAONOFFSts"];
        FCM_5_TSIONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_TSIONOFFSts"];
        FCM_5_TLIONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_TLIONOFFSts"];
        FCM_5_LDWONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_LDWONOFFSts"];
        FCM_5_WarnModSts = CanConfiguration::Instance().SignalParsers()["FCM_5_WarnModSts"];
        FCM_5_LDPONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_LDPONOFFSts"];
        FCM_5_LDWLDPSnvtySts = CanConfiguration::Instance().SignalParsers()["FCM_5_LDWLDPSnvtySts"];
        FCM_5_ELKONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_5_ELKONOFFSts"];
        SLWFONOFFSts = CanConfiguration::Instance().SignalParsers()["SLWFONOFFSts"];
        SLASpdlimitWarningAudSWSts = CanConfiguration::Instance().SignalParsers()["SLASpdlimitWarningAudSWSts"];
        FCM_5_SpeedLmtNmberAb = CanConfiguration::Instance().SignalParsers()["FCM_5_SpeedLmtNmberAb"];
        FCM_5_SpeedLmtNmberE = CanConfiguration::Instance().SignalParsers()["FCM_5_SpeedLmtNmberE"];
        FCM_5_SLAmodeSWSet = CanConfiguration::Instance().SignalParsers()["FCM_5_SLAmodeSWSet"];
        FCM_5_Resd_1 = CanConfiguration::Instance().SignalParsers()["FCM_5_Resd_1"];
        FCM_5_MsgCntr = CanConfiguration::Instance().SignalParsers()["FCM_5_MsgCntr"];
        FCM_5_CRC = CanConfiguration::Instance().SignalParsers()["FCM_5_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_5_TJAICAExitTextInfoSts.Parser(payload);
        FCM_5_SLAONOFFSts.Parser(payload);
        FCM_5_IESONOFFSts.Parser(payload);
        FCM_5_HMAONOFFSts.Parser(payload);
        FCM_5_TSIONOFFSts.Parser(payload);
        FCM_5_TLIONOFFSts.Parser(payload);
        FCM_5_LDWONOFFSts.Parser(payload);
        FCM_5_WarnModSts.Parser(payload);
        FCM_5_LDPONOFFSts.Parser(payload);
        FCM_5_LDWLDPSnvtySts.Parser(payload);
        FCM_5_ELKONOFFSts.Parser(payload);
        SLWFONOFFSts.Parser(payload);
        SLASpdlimitWarningAudSWSts.Parser(payload);
        FCM_5_SpeedLmtNmberAb.Parser(payload);
        FCM_5_SpeedLmtNmberE.Parser(payload);
        FCM_5_SLAmodeSWSet.Parser(payload);
        FCM_5_Resd_1.Parser(payload);
        FCM_5_MsgCntr.Parser(payload);
        FCM_5_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_5_MSG(FCM_5_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_5_TJAICAExitTextInfoSts.factor;
        offset = FCM_5_TJAICAExitTextInfoSts.offset;
        msg.FCM_5_TJAICAExitTextInfoSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_TJAICAExitTextInfoSts)>::type*>(&FCM_5_TJAICAExitTextInfoSts.signal);
        msg.FCM_5_TJAICAExitTextInfoSts = msg.FCM_5_TJAICAExitTextInfoSts * factor + offset;
        factor = FCM_5_SLAONOFFSts.factor;
        offset = FCM_5_SLAONOFFSts.offset;
        msg.FCM_5_SLAONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_SLAONOFFSts)>::type*>(&FCM_5_SLAONOFFSts.signal);
        msg.FCM_5_SLAONOFFSts = msg.FCM_5_SLAONOFFSts * factor + offset;
        factor = FCM_5_IESONOFFSts.factor;
        offset = FCM_5_IESONOFFSts.offset;
        msg.FCM_5_IESONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_IESONOFFSts)>::type*>(&FCM_5_IESONOFFSts.signal);
        msg.FCM_5_IESONOFFSts = msg.FCM_5_IESONOFFSts * factor + offset;
        factor = FCM_5_HMAONOFFSts.factor;
        offset = FCM_5_HMAONOFFSts.offset;
        msg.FCM_5_HMAONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_HMAONOFFSts)>::type*>(&FCM_5_HMAONOFFSts.signal);
        msg.FCM_5_HMAONOFFSts = msg.FCM_5_HMAONOFFSts * factor + offset;
        factor = FCM_5_TSIONOFFSts.factor;
        offset = FCM_5_TSIONOFFSts.offset;
        msg.FCM_5_TSIONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_TSIONOFFSts)>::type*>(&FCM_5_TSIONOFFSts.signal);
        msg.FCM_5_TSIONOFFSts = msg.FCM_5_TSIONOFFSts * factor + offset;
        factor = FCM_5_TLIONOFFSts.factor;
        offset = FCM_5_TLIONOFFSts.offset;
        msg.FCM_5_TLIONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_TLIONOFFSts)>::type*>(&FCM_5_TLIONOFFSts.signal);
        msg.FCM_5_TLIONOFFSts = msg.FCM_5_TLIONOFFSts * factor + offset;
        factor = FCM_5_LDWONOFFSts.factor;
        offset = FCM_5_LDWONOFFSts.offset;
        msg.FCM_5_LDWONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_LDWONOFFSts)>::type*>(&FCM_5_LDWONOFFSts.signal);
        msg.FCM_5_LDWONOFFSts = msg.FCM_5_LDWONOFFSts * factor + offset;
        factor = FCM_5_WarnModSts.factor;
        offset = FCM_5_WarnModSts.offset;
        msg.FCM_5_WarnModSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_WarnModSts)>::type*>(&FCM_5_WarnModSts.signal);
        msg.FCM_5_WarnModSts = msg.FCM_5_WarnModSts * factor + offset;
        factor = FCM_5_LDPONOFFSts.factor;
        offset = FCM_5_LDPONOFFSts.offset;
        msg.FCM_5_LDPONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_LDPONOFFSts)>::type*>(&FCM_5_LDPONOFFSts.signal);
        msg.FCM_5_LDPONOFFSts = msg.FCM_5_LDPONOFFSts * factor + offset;
        factor = FCM_5_LDWLDPSnvtySts.factor;
        offset = FCM_5_LDWLDPSnvtySts.offset;
        msg.FCM_5_LDWLDPSnvtySts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_LDWLDPSnvtySts)>::type*>(&FCM_5_LDWLDPSnvtySts.signal);
        msg.FCM_5_LDWLDPSnvtySts = msg.FCM_5_LDWLDPSnvtySts * factor + offset;
        factor = FCM_5_ELKONOFFSts.factor;
        offset = FCM_5_ELKONOFFSts.offset;
        msg.FCM_5_ELKONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_5_ELKONOFFSts)>::type*>(&FCM_5_ELKONOFFSts.signal);
        msg.FCM_5_ELKONOFFSts = msg.FCM_5_ELKONOFFSts * factor + offset;
        factor = SLWFONOFFSts.factor;
        offset = SLWFONOFFSts.offset;
        msg.SLWFONOFFSts = *reinterpret_cast<std::decay<decltype(msg.SLWFONOFFSts)>::type*>(&SLWFONOFFSts.signal);
        msg.SLWFONOFFSts = msg.SLWFONOFFSts * factor + offset;
        factor = SLASpdlimitWarningAudSWSts.factor;
        offset = SLASpdlimitWarningAudSWSts.offset;
        msg.SLASpdlimitWarningAudSWSts = *reinterpret_cast<std::decay<decltype(msg.SLASpdlimitWarningAudSWSts)>::type*>(&SLASpdlimitWarningAudSWSts.signal);
        msg.SLASpdlimitWarningAudSWSts = msg.SLASpdlimitWarningAudSWSts * factor + offset;
        factor = FCM_5_SpeedLmtNmberAb.factor;
        offset = FCM_5_SpeedLmtNmberAb.offset;
        msg.FCM_5_SpeedLmtNmberAb = *reinterpret_cast<std::decay<decltype(msg.FCM_5_SpeedLmtNmberAb)>::type*>(&FCM_5_SpeedLmtNmberAb.signal);
        msg.FCM_5_SpeedLmtNmberAb = msg.FCM_5_SpeedLmtNmberAb * factor + offset;
        factor = FCM_5_SpeedLmtNmberE.factor;
        offset = FCM_5_SpeedLmtNmberE.offset;
        msg.FCM_5_SpeedLmtNmberE = *reinterpret_cast<std::decay<decltype(msg.FCM_5_SpeedLmtNmberE)>::type*>(&FCM_5_SpeedLmtNmberE.signal);
        msg.FCM_5_SpeedLmtNmberE = msg.FCM_5_SpeedLmtNmberE * factor + offset;
        factor = FCM_5_SLAmodeSWSet.factor;
        offset = FCM_5_SLAmodeSWSet.offset;
        msg.FCM_5_SLAmodeSWSet = *reinterpret_cast<std::decay<decltype(msg.FCM_5_SLAmodeSWSet)>::type*>(&FCM_5_SLAmodeSWSet.signal);
        msg.FCM_5_SLAmodeSWSet = msg.FCM_5_SLAmodeSWSet * factor + offset;
        factor = FCM_5_Resd_1.factor;
        offset = FCM_5_Resd_1.offset;
        msg.FCM_5_Resd_1 = *reinterpret_cast<std::decay<decltype(msg.FCM_5_Resd_1)>::type*>(&FCM_5_Resd_1.signal);
        msg.FCM_5_Resd_1 = msg.FCM_5_Resd_1 * factor + offset;
        factor = FCM_5_MsgCntr.factor;
        offset = FCM_5_MsgCntr.offset;
        msg.FCM_5_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.FCM_5_MsgCntr)>::type*>(&FCM_5_MsgCntr.signal);
        msg.FCM_5_MsgCntr = msg.FCM_5_MsgCntr * factor + offset;
        factor = FCM_5_CRC.factor;
        offset = FCM_5_CRC.offset;
        msg.FCM_5_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_5_CRC)>::type*>(&FCM_5_CRC.signal);
        msg.FCM_5_CRC = msg.FCM_5_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_5_MSG can_struct;
        CanParser2CanStruct_FCM_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_5_MSGMsg>();
        Struct2Proto_FCM_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_5") != nullptr) {
            DFHLOG_I("fcm_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_5");
            return false;
         }
    }
};

struct FCM_10_Parser {
    SignalParser FCM_10_TSISysSts;

    SignalParser FCM_10_TLISysSts;

    SignalParser FCM_10_TSISgnGiWay;

    SignalParser FCM_10_TSISgnForb;

    SignalParser FCM_10_TSISgnLongStayDisp;

    SignalParser FCM_10_TLITrfcLi;

    SignalParser FCM_10_LDPSysSts;

    SignalParser FCM_10_LDWSysSts;

    SignalParser FCM_10_ELKSysSts;

    SignalParser FCM_10_TSINoParkWarn;

    SignalParser FCM_10_TJAICATextinfo_Resd;

    SignalParser FCM_10_TJAICAEnaRcmend_Resd;

    SignalParser FCM_10_LDPTJAELKTakeoverReq;

    SignalParser FCM_10_TJAICAExitTextInfoSts;

    SignalParser FCM_10_SLAONOFFSts;

    SignalParser FCM_10_WarnModSts;

    SignalParser FCM_10_ELKIntvMod;

    SignalParser FCM_10_EgoLeftLineHeatgAg_Resd;

    SignalParser FCM_10_MsgCntr;

    SignalParser FCM_10_CRC;

    FCM_10_Parser() {
        FCM_10_TSISysSts = CanConfiguration::Instance().SignalParsers()["FCM_10_TSISysSts"];
        FCM_10_TLISysSts = CanConfiguration::Instance().SignalParsers()["FCM_10_TLISysSts"];
        FCM_10_TSISgnGiWay = CanConfiguration::Instance().SignalParsers()["FCM_10_TSISgnGiWay"];
        FCM_10_TSISgnForb = CanConfiguration::Instance().SignalParsers()["FCM_10_TSISgnForb"];
        FCM_10_TSISgnLongStayDisp = CanConfiguration::Instance().SignalParsers()["FCM_10_TSISgnLongStayDisp"];
        FCM_10_TLITrfcLi = CanConfiguration::Instance().SignalParsers()["FCM_10_TLITrfcLi"];
        FCM_10_LDPSysSts = CanConfiguration::Instance().SignalParsers()["FCM_10_LDPSysSts"];
        FCM_10_LDWSysSts = CanConfiguration::Instance().SignalParsers()["FCM_10_LDWSysSts"];
        FCM_10_ELKSysSts = CanConfiguration::Instance().SignalParsers()["FCM_10_ELKSysSts"];
        FCM_10_TSINoParkWarn = CanConfiguration::Instance().SignalParsers()["FCM_10_TSINoParkWarn"];
        FCM_10_TJAICATextinfo_Resd = CanConfiguration::Instance().SignalParsers()["FCM_10_TJAICATextinfo_Resd"];
        FCM_10_TJAICAEnaRcmend_Resd = CanConfiguration::Instance().SignalParsers()["FCM_10_TJAICAEnaRcmend_Resd"];
        FCM_10_LDPTJAELKTakeoverReq = CanConfiguration::Instance().SignalParsers()["FCM_10_LDPTJAELKTakeoverReq"];
        FCM_10_TJAICAExitTextInfoSts = CanConfiguration::Instance().SignalParsers()["FCM_10_TJAICAExitTextInfoSts"];
        FCM_10_SLAONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_10_SLAONOFFSts"];
        FCM_10_WarnModSts = CanConfiguration::Instance().SignalParsers()["FCM_10_WarnModSts"];
        FCM_10_ELKIntvMod = CanConfiguration::Instance().SignalParsers()["FCM_10_ELKIntvMod"];
        FCM_10_EgoLeftLineHeatgAg_Resd = CanConfiguration::Instance().SignalParsers()["FCM_10_EgoLeftLineHeatgAg_Resd"];
        FCM_10_MsgCntr = CanConfiguration::Instance().SignalParsers()["FCM_10_MsgCntr"];
        FCM_10_CRC = CanConfiguration::Instance().SignalParsers()["FCM_10_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_10_TSISysSts.Parser(payload);
        FCM_10_TLISysSts.Parser(payload);
        FCM_10_TSISgnGiWay.Parser(payload);
        FCM_10_TSISgnForb.Parser(payload);
        FCM_10_TSISgnLongStayDisp.Parser(payload);
        FCM_10_TLITrfcLi.Parser(payload);
        FCM_10_LDPSysSts.Parser(payload);
        FCM_10_LDWSysSts.Parser(payload);
        FCM_10_ELKSysSts.Parser(payload);
        FCM_10_TSINoParkWarn.Parser(payload);
        FCM_10_TJAICATextinfo_Resd.Parser(payload);
        FCM_10_TJAICAEnaRcmend_Resd.Parser(payload);
        FCM_10_LDPTJAELKTakeoverReq.Parser(payload);
        FCM_10_TJAICAExitTextInfoSts.Parser(payload);
        FCM_10_SLAONOFFSts.Parser(payload);
        FCM_10_WarnModSts.Parser(payload);
        FCM_10_ELKIntvMod.Parser(payload);
        FCM_10_EgoLeftLineHeatgAg_Resd.Parser(payload);
        FCM_10_MsgCntr.Parser(payload);
        FCM_10_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_10_MSG(FCM_10_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_10_TSISysSts.factor;
        offset = FCM_10_TSISysSts.offset;
        msg.FCM_10_TSISysSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TSISysSts)>::type*>(&FCM_10_TSISysSts.signal);
        msg.FCM_10_TSISysSts = msg.FCM_10_TSISysSts * factor + offset;
        factor = FCM_10_TLISysSts.factor;
        offset = FCM_10_TLISysSts.offset;
        msg.FCM_10_TLISysSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TLISysSts)>::type*>(&FCM_10_TLISysSts.signal);
        msg.FCM_10_TLISysSts = msg.FCM_10_TLISysSts * factor + offset;
        factor = FCM_10_TSISgnGiWay.factor;
        offset = FCM_10_TSISgnGiWay.offset;
        msg.FCM_10_TSISgnGiWay = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TSISgnGiWay)>::type*>(&FCM_10_TSISgnGiWay.signal);
        msg.FCM_10_TSISgnGiWay = msg.FCM_10_TSISgnGiWay * factor + offset;
        factor = FCM_10_TSISgnForb.factor;
        offset = FCM_10_TSISgnForb.offset;
        msg.FCM_10_TSISgnForb = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TSISgnForb)>::type*>(&FCM_10_TSISgnForb.signal);
        msg.FCM_10_TSISgnForb = msg.FCM_10_TSISgnForb * factor + offset;
        factor = FCM_10_TSISgnLongStayDisp.factor;
        offset = FCM_10_TSISgnLongStayDisp.offset;
        msg.FCM_10_TSISgnLongStayDisp = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TSISgnLongStayDisp)>::type*>(&FCM_10_TSISgnLongStayDisp.signal);
        msg.FCM_10_TSISgnLongStayDisp = msg.FCM_10_TSISgnLongStayDisp * factor + offset;
        factor = FCM_10_TLITrfcLi.factor;
        offset = FCM_10_TLITrfcLi.offset;
        msg.FCM_10_TLITrfcLi = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TLITrfcLi)>::type*>(&FCM_10_TLITrfcLi.signal);
        msg.FCM_10_TLITrfcLi = msg.FCM_10_TLITrfcLi * factor + offset;
        factor = FCM_10_LDPSysSts.factor;
        offset = FCM_10_LDPSysSts.offset;
        msg.FCM_10_LDPSysSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_LDPSysSts)>::type*>(&FCM_10_LDPSysSts.signal);
        msg.FCM_10_LDPSysSts = msg.FCM_10_LDPSysSts * factor + offset;
        factor = FCM_10_LDWSysSts.factor;
        offset = FCM_10_LDWSysSts.offset;
        msg.FCM_10_LDWSysSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_LDWSysSts)>::type*>(&FCM_10_LDWSysSts.signal);
        msg.FCM_10_LDWSysSts = msg.FCM_10_LDWSysSts * factor + offset;
        factor = FCM_10_ELKSysSts.factor;
        offset = FCM_10_ELKSysSts.offset;
        msg.FCM_10_ELKSysSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_ELKSysSts)>::type*>(&FCM_10_ELKSysSts.signal);
        msg.FCM_10_ELKSysSts = msg.FCM_10_ELKSysSts * factor + offset;
        factor = FCM_10_TSINoParkWarn.factor;
        offset = FCM_10_TSINoParkWarn.offset;
        msg.FCM_10_TSINoParkWarn = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TSINoParkWarn)>::type*>(&FCM_10_TSINoParkWarn.signal);
        msg.FCM_10_TSINoParkWarn = msg.FCM_10_TSINoParkWarn * factor + offset;
        factor = FCM_10_TJAICATextinfo_Resd.factor;
        offset = FCM_10_TJAICATextinfo_Resd.offset;
        msg.FCM_10_TJAICATextinfo_Resd = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TJAICATextinfo_Resd)>::type*>(&FCM_10_TJAICATextinfo_Resd.signal);
        msg.FCM_10_TJAICATextinfo_Resd = msg.FCM_10_TJAICATextinfo_Resd * factor + offset;
        factor = FCM_10_TJAICAEnaRcmend_Resd.factor;
        offset = FCM_10_TJAICAEnaRcmend_Resd.offset;
        msg.FCM_10_TJAICAEnaRcmend_Resd = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TJAICAEnaRcmend_Resd)>::type*>(&FCM_10_TJAICAEnaRcmend_Resd.signal);
        msg.FCM_10_TJAICAEnaRcmend_Resd = msg.FCM_10_TJAICAEnaRcmend_Resd * factor + offset;
        factor = FCM_10_LDPTJAELKTakeoverReq.factor;
        offset = FCM_10_LDPTJAELKTakeoverReq.offset;
        msg.FCM_10_LDPTJAELKTakeoverReq = *reinterpret_cast<std::decay<decltype(msg.FCM_10_LDPTJAELKTakeoverReq)>::type*>(&FCM_10_LDPTJAELKTakeoverReq.signal);
        msg.FCM_10_LDPTJAELKTakeoverReq = msg.FCM_10_LDPTJAELKTakeoverReq * factor + offset;
        factor = FCM_10_TJAICAExitTextInfoSts.factor;
        offset = FCM_10_TJAICAExitTextInfoSts.offset;
        msg.FCM_10_TJAICAExitTextInfoSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_TJAICAExitTextInfoSts)>::type*>(&FCM_10_TJAICAExitTextInfoSts.signal);
        msg.FCM_10_TJAICAExitTextInfoSts = msg.FCM_10_TJAICAExitTextInfoSts * factor + offset;
        factor = FCM_10_SLAONOFFSts.factor;
        offset = FCM_10_SLAONOFFSts.offset;
        msg.FCM_10_SLAONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_SLAONOFFSts)>::type*>(&FCM_10_SLAONOFFSts.signal);
        msg.FCM_10_SLAONOFFSts = msg.FCM_10_SLAONOFFSts * factor + offset;
        factor = FCM_10_WarnModSts.factor;
        offset = FCM_10_WarnModSts.offset;
        msg.FCM_10_WarnModSts = *reinterpret_cast<std::decay<decltype(msg.FCM_10_WarnModSts)>::type*>(&FCM_10_WarnModSts.signal);
        msg.FCM_10_WarnModSts = msg.FCM_10_WarnModSts * factor + offset;
        factor = FCM_10_ELKIntvMod.factor;
        offset = FCM_10_ELKIntvMod.offset;
        msg.FCM_10_ELKIntvMod = *reinterpret_cast<std::decay<decltype(msg.FCM_10_ELKIntvMod)>::type*>(&FCM_10_ELKIntvMod.signal);
        msg.FCM_10_ELKIntvMod = msg.FCM_10_ELKIntvMod * factor + offset;
        factor = FCM_10_EgoLeftLineHeatgAg_Resd.factor;
        offset = FCM_10_EgoLeftLineHeatgAg_Resd.offset;
        msg.FCM_10_EgoLeftLineHeatgAg_Resd = *reinterpret_cast<std::decay<decltype(msg.FCM_10_EgoLeftLineHeatgAg_Resd)>::type*>(&FCM_10_EgoLeftLineHeatgAg_Resd.signal);
        msg.FCM_10_EgoLeftLineHeatgAg_Resd = msg.FCM_10_EgoLeftLineHeatgAg_Resd * factor + offset;
        factor = FCM_10_MsgCntr.factor;
        offset = FCM_10_MsgCntr.offset;
        msg.FCM_10_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.FCM_10_MsgCntr)>::type*>(&FCM_10_MsgCntr.signal);
        msg.FCM_10_MsgCntr = msg.FCM_10_MsgCntr * factor + offset;
        factor = FCM_10_CRC.factor;
        offset = FCM_10_CRC.offset;
        msg.FCM_10_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_10_CRC)>::type*>(&FCM_10_CRC.signal);
        msg.FCM_10_CRC = msg.FCM_10_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_10_MSG can_struct;
        CanParser2CanStruct_FCM_10_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_10_MSGMsg>();
        Struct2Proto_FCM_10_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_10") != nullptr) {
            DFHLOG_I("fcm_10");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_10")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_10");
            return false;
         }
    }
};

struct FCM_FRM_1_Parser {
    SignalParser ACCTarAcc;

    SignalParser VLCShutdownMode;

    SignalParser ACCMode_ESP;

    SignalParser ComfortAccUpperValue;

    SignalParser BrakePreferred;

    SignalParser ComfortAccLowerValue;

    SignalParser DriveOff;

    SignalParser LimitAccUpperValue;

    SignalParser DecToStop;

    SignalParser LimitAccLowerValue;

    SignalParser ACC_AccECGPOvrd;

    SignalParser HBALevel;

    SignalParser HBARequest;

    SignalParser PrefillRequest;

    SignalParser FCM_FRM_1_MessageCounter;

    SignalParser FCM_FRM_1_CRC;

    FCM_FRM_1_Parser() {
        ACCTarAcc = CanConfiguration::Instance().SignalParsers()["ACCTarAcc"];
        VLCShutdownMode = CanConfiguration::Instance().SignalParsers()["VLCShutdownMode"];
        ACCMode_ESP = CanConfiguration::Instance().SignalParsers()["ACCMode_ESP"];
        ComfortAccUpperValue = CanConfiguration::Instance().SignalParsers()["ComfortAccUpperValue"];
        BrakePreferred = CanConfiguration::Instance().SignalParsers()["BrakePreferred"];
        ComfortAccLowerValue = CanConfiguration::Instance().SignalParsers()["ComfortAccLowerValue"];
        DriveOff = CanConfiguration::Instance().SignalParsers()["DriveOff"];
        LimitAccUpperValue = CanConfiguration::Instance().SignalParsers()["LimitAccUpperValue"];
        DecToStop = CanConfiguration::Instance().SignalParsers()["DecToStop"];
        LimitAccLowerValue = CanConfiguration::Instance().SignalParsers()["LimitAccLowerValue"];
        ACC_AccECGPOvrd = CanConfiguration::Instance().SignalParsers()["ACC_AccECGPOvrd"];
        HBALevel = CanConfiguration::Instance().SignalParsers()["HBALevel"];
        HBARequest = CanConfiguration::Instance().SignalParsers()["HBARequest"];
        PrefillRequest = CanConfiguration::Instance().SignalParsers()["PrefillRequest"];
        FCM_FRM_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["FCM_FRM_1_MessageCounter"];
        FCM_FRM_1_CRC = CanConfiguration::Instance().SignalParsers()["FCM_FRM_1_CRC"];
    }

    void Parser(uint8_t* payload){
        ACCTarAcc.Parser(payload);
        VLCShutdownMode.Parser(payload);
        ACCMode_ESP.Parser(payload);
        ComfortAccUpperValue.Parser(payload);
        BrakePreferred.Parser(payload);
        ComfortAccLowerValue.Parser(payload);
        DriveOff.Parser(payload);
        LimitAccUpperValue.Parser(payload);
        DecToStop.Parser(payload);
        LimitAccLowerValue.Parser(payload);
        ACC_AccECGPOvrd.Parser(payload);
        HBALevel.Parser(payload);
        HBARequest.Parser(payload);
        PrefillRequest.Parser(payload);
        FCM_FRM_1_MessageCounter.Parser(payload);
        FCM_FRM_1_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_FRM_1_MSG(FCM_FRM_1_MSG& msg) {
        double factor;
        double offset;
        factor = ACCTarAcc.factor;
        offset = ACCTarAcc.offset;
        msg.ACCTarAcc = *reinterpret_cast<std::decay<decltype(msg.ACCTarAcc)>::type*>(&ACCTarAcc.signal);
        msg.ACCTarAcc = msg.ACCTarAcc * factor + offset;
        factor = VLCShutdownMode.factor;
        offset = VLCShutdownMode.offset;
        msg.VLCShutdownMode = *reinterpret_cast<std::decay<decltype(msg.VLCShutdownMode)>::type*>(&VLCShutdownMode.signal);
        msg.VLCShutdownMode = msg.VLCShutdownMode * factor + offset;
        factor = ACCMode_ESP.factor;
        offset = ACCMode_ESP.offset;
        msg.ACCMode_ESP = *reinterpret_cast<std::decay<decltype(msg.ACCMode_ESP)>::type*>(&ACCMode_ESP.signal);
        msg.ACCMode_ESP = msg.ACCMode_ESP * factor + offset;
        factor = ComfortAccUpperValue.factor;
        offset = ComfortAccUpperValue.offset;
        msg.ComfortAccUpperValue = *reinterpret_cast<std::decay<decltype(msg.ComfortAccUpperValue)>::type*>(&ComfortAccUpperValue.signal);
        msg.ComfortAccUpperValue = msg.ComfortAccUpperValue * factor + offset;
        factor = BrakePreferred.factor;
        offset = BrakePreferred.offset;
        msg.BrakePreferred = *reinterpret_cast<std::decay<decltype(msg.BrakePreferred)>::type*>(&BrakePreferred.signal);
        msg.BrakePreferred = msg.BrakePreferred * factor + offset;
        factor = ComfortAccLowerValue.factor;
        offset = ComfortAccLowerValue.offset;
        msg.ComfortAccLowerValue = *reinterpret_cast<std::decay<decltype(msg.ComfortAccLowerValue)>::type*>(&ComfortAccLowerValue.signal);
        msg.ComfortAccLowerValue = msg.ComfortAccLowerValue * factor + offset;
        factor = DriveOff.factor;
        offset = DriveOff.offset;
        msg.DriveOff = *reinterpret_cast<std::decay<decltype(msg.DriveOff)>::type*>(&DriveOff.signal);
        msg.DriveOff = msg.DriveOff * factor + offset;
        factor = LimitAccUpperValue.factor;
        offset = LimitAccUpperValue.offset;
        msg.LimitAccUpperValue = *reinterpret_cast<std::decay<decltype(msg.LimitAccUpperValue)>::type*>(&LimitAccUpperValue.signal);
        msg.LimitAccUpperValue = msg.LimitAccUpperValue * factor + offset;
        factor = DecToStop.factor;
        offset = DecToStop.offset;
        msg.DecToStop = *reinterpret_cast<std::decay<decltype(msg.DecToStop)>::type*>(&DecToStop.signal);
        msg.DecToStop = msg.DecToStop * factor + offset;
        factor = LimitAccLowerValue.factor;
        offset = LimitAccLowerValue.offset;
        msg.LimitAccLowerValue = *reinterpret_cast<std::decay<decltype(msg.LimitAccLowerValue)>::type*>(&LimitAccLowerValue.signal);
        msg.LimitAccLowerValue = msg.LimitAccLowerValue * factor + offset;
        factor = ACC_AccECGPOvrd.factor;
        offset = ACC_AccECGPOvrd.offset;
        msg.ACC_AccECGPOvrd = *reinterpret_cast<std::decay<decltype(msg.ACC_AccECGPOvrd)>::type*>(&ACC_AccECGPOvrd.signal);
        msg.ACC_AccECGPOvrd = msg.ACC_AccECGPOvrd * factor + offset;
        factor = HBALevel.factor;
        offset = HBALevel.offset;
        msg.HBALevel = *reinterpret_cast<std::decay<decltype(msg.HBALevel)>::type*>(&HBALevel.signal);
        msg.HBALevel = msg.HBALevel * factor + offset;
        factor = HBARequest.factor;
        offset = HBARequest.offset;
        msg.HBARequest = *reinterpret_cast<std::decay<decltype(msg.HBARequest)>::type*>(&HBARequest.signal);
        msg.HBARequest = msg.HBARequest * factor + offset;
        factor = PrefillRequest.factor;
        offset = PrefillRequest.offset;
        msg.PrefillRequest = *reinterpret_cast<std::decay<decltype(msg.PrefillRequest)>::type*>(&PrefillRequest.signal);
        msg.PrefillRequest = msg.PrefillRequest * factor + offset;
        factor = FCM_FRM_1_MessageCounter.factor;
        offset = FCM_FRM_1_MessageCounter.offset;
        msg.FCM_FRM_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_1_MessageCounter)>::type*>(&FCM_FRM_1_MessageCounter.signal);
        msg.FCM_FRM_1_MessageCounter = msg.FCM_FRM_1_MessageCounter * factor + offset;
        factor = FCM_FRM_1_CRC.factor;
        offset = FCM_FRM_1_CRC.offset;
        msg.FCM_FRM_1_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_1_CRC)>::type*>(&FCM_FRM_1_CRC.signal);
        msg.FCM_FRM_1_CRC = msg.FCM_FRM_1_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_FRM_1_MSG can_struct;
        CanParser2CanStruct_FCM_FRM_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_FRM_1_MSGMsg>();
        Struct2Proto_FCM_FRM_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_frm_1") != nullptr) {
            DFHLOG_I("fcm_frm_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_frm_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_frm_1");
            return false;
         }
    }
};

struct FCM_FRM_2_Parser {
    SignalParser AEBTarDec;

    SignalParser AEBDecCtrlRequest;

    SignalParser ACCMinimumBraking;

    SignalParser ACCStartStopInfo;

    SignalParser AEBReq;

    SignalParser FCM_FRM_2_Reserved1;

    SignalParser AWBRequest;

    SignalParser AWBLevel;

    SignalParser FCM_FRM_2_Textinfo_Info;

    SignalParser FCM_FRM_2_Reserved2;

    SignalParser FCM_FRM_2_MessageCounter;

    SignalParser FCM_FRM_2_CRC;

    FCM_FRM_2_Parser() {
        AEBTarDec = CanConfiguration::Instance().SignalParsers()["AEBTarDec"];
        AEBDecCtrlRequest = CanConfiguration::Instance().SignalParsers()["AEBDecCtrlRequest"];
        ACCMinimumBraking = CanConfiguration::Instance().SignalParsers()["ACCMinimumBraking"];
        ACCStartStopInfo = CanConfiguration::Instance().SignalParsers()["ACCStartStopInfo"];
        AEBReq = CanConfiguration::Instance().SignalParsers()["AEBReq"];
        FCM_FRM_2_Reserved1 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_2_Reserved1"];
        AWBRequest = CanConfiguration::Instance().SignalParsers()["AWBRequest"];
        AWBLevel = CanConfiguration::Instance().SignalParsers()["AWBLevel"];
        FCM_FRM_2_Textinfo_Info = CanConfiguration::Instance().SignalParsers()["FCM_FRM_2_Textinfo_Info"];
        FCM_FRM_2_Reserved2 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_2_Reserved2"];
        FCM_FRM_2_MessageCounter = CanConfiguration::Instance().SignalParsers()["FCM_FRM_2_MessageCounter"];
        FCM_FRM_2_CRC = CanConfiguration::Instance().SignalParsers()["FCM_FRM_2_CRC"];
    }

    void Parser(uint8_t* payload){
        AEBTarDec.Parser(payload);
        AEBDecCtrlRequest.Parser(payload);
        ACCMinimumBraking.Parser(payload);
        ACCStartStopInfo.Parser(payload);
        AEBReq.Parser(payload);
        FCM_FRM_2_Reserved1.Parser(payload);
        AWBRequest.Parser(payload);
        AWBLevel.Parser(payload);
        FCM_FRM_2_Textinfo_Info.Parser(payload);
        FCM_FRM_2_Reserved2.Parser(payload);
        FCM_FRM_2_MessageCounter.Parser(payload);
        FCM_FRM_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_FRM_2_MSG(FCM_FRM_2_MSG& msg) {
        double factor;
        double offset;
        factor = AEBTarDec.factor;
        offset = AEBTarDec.offset;
        msg.AEBTarDec = *reinterpret_cast<std::decay<decltype(msg.AEBTarDec)>::type*>(&AEBTarDec.signal);
        msg.AEBTarDec = msg.AEBTarDec * factor + offset;
        factor = AEBDecCtrlRequest.factor;
        offset = AEBDecCtrlRequest.offset;
        msg.AEBDecCtrlRequest = *reinterpret_cast<std::decay<decltype(msg.AEBDecCtrlRequest)>::type*>(&AEBDecCtrlRequest.signal);
        msg.AEBDecCtrlRequest = msg.AEBDecCtrlRequest * factor + offset;
        factor = ACCMinimumBraking.factor;
        offset = ACCMinimumBraking.offset;
        msg.ACCMinimumBraking = *reinterpret_cast<std::decay<decltype(msg.ACCMinimumBraking)>::type*>(&ACCMinimumBraking.signal);
        msg.ACCMinimumBraking = msg.ACCMinimumBraking * factor + offset;
        factor = ACCStartStopInfo.factor;
        offset = ACCStartStopInfo.offset;
        msg.ACCStartStopInfo = *reinterpret_cast<std::decay<decltype(msg.ACCStartStopInfo)>::type*>(&ACCStartStopInfo.signal);
        msg.ACCStartStopInfo = msg.ACCStartStopInfo * factor + offset;
        factor = AEBReq.factor;
        offset = AEBReq.offset;
        msg.AEBReq = *reinterpret_cast<std::decay<decltype(msg.AEBReq)>::type*>(&AEBReq.signal);
        msg.AEBReq = msg.AEBReq * factor + offset;
        factor = FCM_FRM_2_Reserved1.factor;
        offset = FCM_FRM_2_Reserved1.offset;
        msg.FCM_FRM_2_Reserved1 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_2_Reserved1)>::type*>(&FCM_FRM_2_Reserved1.signal);
        msg.FCM_FRM_2_Reserved1 = msg.FCM_FRM_2_Reserved1 * factor + offset;
        factor = AWBRequest.factor;
        offset = AWBRequest.offset;
        msg.AWBRequest = *reinterpret_cast<std::decay<decltype(msg.AWBRequest)>::type*>(&AWBRequest.signal);
        msg.AWBRequest = msg.AWBRequest * factor + offset;
        factor = AWBLevel.factor;
        offset = AWBLevel.offset;
        msg.AWBLevel = *reinterpret_cast<std::decay<decltype(msg.AWBLevel)>::type*>(&AWBLevel.signal);
        msg.AWBLevel = msg.AWBLevel * factor + offset;
        factor = FCM_FRM_2_Textinfo_Info.factor;
        offset = FCM_FRM_2_Textinfo_Info.offset;
        msg.FCM_FRM_2_Textinfo_Info = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_2_Textinfo_Info)>::type*>(&FCM_FRM_2_Textinfo_Info.signal);
        msg.FCM_FRM_2_Textinfo_Info = msg.FCM_FRM_2_Textinfo_Info * factor + offset;
        factor = FCM_FRM_2_Reserved2.factor;
        offset = FCM_FRM_2_Reserved2.offset;
        msg.FCM_FRM_2_Reserved2 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_2_Reserved2)>::type*>(&FCM_FRM_2_Reserved2.signal);
        msg.FCM_FRM_2_Reserved2 = msg.FCM_FRM_2_Reserved2 * factor + offset;
        factor = FCM_FRM_2_MessageCounter.factor;
        offset = FCM_FRM_2_MessageCounter.offset;
        msg.FCM_FRM_2_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_2_MessageCounter)>::type*>(&FCM_FRM_2_MessageCounter.signal);
        msg.FCM_FRM_2_MessageCounter = msg.FCM_FRM_2_MessageCounter * factor + offset;
        factor = FCM_FRM_2_CRC.factor;
        offset = FCM_FRM_2_CRC.offset;
        msg.FCM_FRM_2_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_2_CRC)>::type*>(&FCM_FRM_2_CRC.signal);
        msg.FCM_FRM_2_CRC = msg.FCM_FRM_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_FRM_2_MSG can_struct;
        CanParser2CanStruct_FCM_FRM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_FRM_2_MSGMsg>();
        Struct2Proto_FCM_FRM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_frm_2") != nullptr) {
            DFHLOG_I("fcm_frm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_frm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_frm_2");
            return false;
         }
    }
};

struct FCM_FRM_3_Parser {
    SignalParser FCM_FRM_3_Resd1;

    SignalParser FCM_FRM_3_Resd2;

    SignalParser FCM_FRM_3_Resd3;

    SignalParser FCM_FRM_3_Resd4;

    SignalParser FCM_FRM_3_Resd6;

    SignalParser FCM_FRM_3_Resd7;

    SignalParser FCM_FRM_3_Resd8;

    SignalParser FCM_FRM_3_Resd9;

    SignalParser ACCModeDummy;

    SignalParser FCM_FRM_3_Resd10;

    SignalParser FCM_FRM_3_Resd11;

    SignalParser FCM_FRM_3_Resd12;

    SignalParser FCM_FRM_3_Resd13;

    SignalParser FCM_FRM_3_Resd14;

    SignalParser FCM_FRM_3_Resd15;

    SignalParser FCM_FRM_3_Resd16;

    SignalParser FCM_FRM_3_Resd17;

    SignalParser FCM_FRM_3_Resd18;

    SignalParser FCM_FRM_3_MessageCounter;

    SignalParser FCM_FRM_3_CRC;

    FCM_FRM_3_Parser() {
        FCM_FRM_3_Resd1 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd1"];
        FCM_FRM_3_Resd2 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd2"];
        FCM_FRM_3_Resd3 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd3"];
        FCM_FRM_3_Resd4 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd4"];
        FCM_FRM_3_Resd6 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd6"];
        FCM_FRM_3_Resd7 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd7"];
        FCM_FRM_3_Resd8 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd8"];
        FCM_FRM_3_Resd9 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd9"];
        ACCModeDummy = CanConfiguration::Instance().SignalParsers()["ACCModeDummy"];
        FCM_FRM_3_Resd10 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd10"];
        FCM_FRM_3_Resd11 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd11"];
        FCM_FRM_3_Resd12 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd12"];
        FCM_FRM_3_Resd13 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd13"];
        FCM_FRM_3_Resd14 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd14"];
        FCM_FRM_3_Resd15 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd15"];
        FCM_FRM_3_Resd16 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd16"];
        FCM_FRM_3_Resd17 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd17"];
        FCM_FRM_3_Resd18 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_Resd18"];
        FCM_FRM_3_MessageCounter = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_MessageCounter"];
        FCM_FRM_3_CRC = CanConfiguration::Instance().SignalParsers()["FCM_FRM_3_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_FRM_3_Resd1.Parser(payload);
        FCM_FRM_3_Resd2.Parser(payload);
        FCM_FRM_3_Resd3.Parser(payload);
        FCM_FRM_3_Resd4.Parser(payload);
        FCM_FRM_3_Resd6.Parser(payload);
        FCM_FRM_3_Resd7.Parser(payload);
        FCM_FRM_3_Resd8.Parser(payload);
        FCM_FRM_3_Resd9.Parser(payload);
        ACCModeDummy.Parser(payload);
        FCM_FRM_3_Resd10.Parser(payload);
        FCM_FRM_3_Resd11.Parser(payload);
        FCM_FRM_3_Resd12.Parser(payload);
        FCM_FRM_3_Resd13.Parser(payload);
        FCM_FRM_3_Resd14.Parser(payload);
        FCM_FRM_3_Resd15.Parser(payload);
        FCM_FRM_3_Resd16.Parser(payload);
        FCM_FRM_3_Resd17.Parser(payload);
        FCM_FRM_3_Resd18.Parser(payload);
        FCM_FRM_3_MessageCounter.Parser(payload);
        FCM_FRM_3_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_FRM_3_MSG(FCM_FRM_3_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_FRM_3_Resd1.factor;
        offset = FCM_FRM_3_Resd1.offset;
        msg.FCM_FRM_3_Resd1 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd1)>::type*>(&FCM_FRM_3_Resd1.signal);
        msg.FCM_FRM_3_Resd1 = msg.FCM_FRM_3_Resd1 * factor + offset;
        factor = FCM_FRM_3_Resd2.factor;
        offset = FCM_FRM_3_Resd2.offset;
        msg.FCM_FRM_3_Resd2 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd2)>::type*>(&FCM_FRM_3_Resd2.signal);
        msg.FCM_FRM_3_Resd2 = msg.FCM_FRM_3_Resd2 * factor + offset;
        factor = FCM_FRM_3_Resd3.factor;
        offset = FCM_FRM_3_Resd3.offset;
        msg.FCM_FRM_3_Resd3 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd3)>::type*>(&FCM_FRM_3_Resd3.signal);
        msg.FCM_FRM_3_Resd3 = msg.FCM_FRM_3_Resd3 * factor + offset;
        factor = FCM_FRM_3_Resd4.factor;
        offset = FCM_FRM_3_Resd4.offset;
        msg.FCM_FRM_3_Resd4 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd4)>::type*>(&FCM_FRM_3_Resd4.signal);
        msg.FCM_FRM_3_Resd4 = msg.FCM_FRM_3_Resd4 * factor + offset;
        factor = FCM_FRM_3_Resd6.factor;
        offset = FCM_FRM_3_Resd6.offset;
        msg.FCM_FRM_3_Resd6 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd6)>::type*>(&FCM_FRM_3_Resd6.signal);
        msg.FCM_FRM_3_Resd6 = msg.FCM_FRM_3_Resd6 * factor + offset;
        factor = FCM_FRM_3_Resd7.factor;
        offset = FCM_FRM_3_Resd7.offset;
        msg.FCM_FRM_3_Resd7 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd7)>::type*>(&FCM_FRM_3_Resd7.signal);
        msg.FCM_FRM_3_Resd7 = msg.FCM_FRM_3_Resd7 * factor + offset;
        factor = FCM_FRM_3_Resd8.factor;
        offset = FCM_FRM_3_Resd8.offset;
        msg.FCM_FRM_3_Resd8 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd8)>::type*>(&FCM_FRM_3_Resd8.signal);
        msg.FCM_FRM_3_Resd8 = msg.FCM_FRM_3_Resd8 * factor + offset;
        factor = FCM_FRM_3_Resd9.factor;
        offset = FCM_FRM_3_Resd9.offset;
        msg.FCM_FRM_3_Resd9 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd9)>::type*>(&FCM_FRM_3_Resd9.signal);
        msg.FCM_FRM_3_Resd9 = msg.FCM_FRM_3_Resd9 * factor + offset;
        factor = ACCModeDummy.factor;
        offset = ACCModeDummy.offset;
        msg.ACCModeDummy = *reinterpret_cast<std::decay<decltype(msg.ACCModeDummy)>::type*>(&ACCModeDummy.signal);
        msg.ACCModeDummy = msg.ACCModeDummy * factor + offset;
        factor = FCM_FRM_3_Resd10.factor;
        offset = FCM_FRM_3_Resd10.offset;
        msg.FCM_FRM_3_Resd10 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd10)>::type*>(&FCM_FRM_3_Resd10.signal);
        msg.FCM_FRM_3_Resd10 = msg.FCM_FRM_3_Resd10 * factor + offset;
        factor = FCM_FRM_3_Resd11.factor;
        offset = FCM_FRM_3_Resd11.offset;
        msg.FCM_FRM_3_Resd11 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd11)>::type*>(&FCM_FRM_3_Resd11.signal);
        msg.FCM_FRM_3_Resd11 = msg.FCM_FRM_3_Resd11 * factor + offset;
        factor = FCM_FRM_3_Resd12.factor;
        offset = FCM_FRM_3_Resd12.offset;
        msg.FCM_FRM_3_Resd12 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd12)>::type*>(&FCM_FRM_3_Resd12.signal);
        msg.FCM_FRM_3_Resd12 = msg.FCM_FRM_3_Resd12 * factor + offset;
        factor = FCM_FRM_3_Resd13.factor;
        offset = FCM_FRM_3_Resd13.offset;
        msg.FCM_FRM_3_Resd13 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd13)>::type*>(&FCM_FRM_3_Resd13.signal);
        msg.FCM_FRM_3_Resd13 = msg.FCM_FRM_3_Resd13 * factor + offset;
        factor = FCM_FRM_3_Resd14.factor;
        offset = FCM_FRM_3_Resd14.offset;
        msg.FCM_FRM_3_Resd14 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd14)>::type*>(&FCM_FRM_3_Resd14.signal);
        msg.FCM_FRM_3_Resd14 = msg.FCM_FRM_3_Resd14 * factor + offset;
        factor = FCM_FRM_3_Resd15.factor;
        offset = FCM_FRM_3_Resd15.offset;
        msg.FCM_FRM_3_Resd15 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd15)>::type*>(&FCM_FRM_3_Resd15.signal);
        msg.FCM_FRM_3_Resd15 = msg.FCM_FRM_3_Resd15 * factor + offset;
        factor = FCM_FRM_3_Resd16.factor;
        offset = FCM_FRM_3_Resd16.offset;
        msg.FCM_FRM_3_Resd16 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd16)>::type*>(&FCM_FRM_3_Resd16.signal);
        msg.FCM_FRM_3_Resd16 = msg.FCM_FRM_3_Resd16 * factor + offset;
        factor = FCM_FRM_3_Resd17.factor;
        offset = FCM_FRM_3_Resd17.offset;
        msg.FCM_FRM_3_Resd17 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd17)>::type*>(&FCM_FRM_3_Resd17.signal);
        msg.FCM_FRM_3_Resd17 = msg.FCM_FRM_3_Resd17 * factor + offset;
        factor = FCM_FRM_3_Resd18.factor;
        offset = FCM_FRM_3_Resd18.offset;
        msg.FCM_FRM_3_Resd18 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_Resd18)>::type*>(&FCM_FRM_3_Resd18.signal);
        msg.FCM_FRM_3_Resd18 = msg.FCM_FRM_3_Resd18 * factor + offset;
        factor = FCM_FRM_3_MessageCounter.factor;
        offset = FCM_FRM_3_MessageCounter.offset;
        msg.FCM_FRM_3_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_MessageCounter)>::type*>(&FCM_FRM_3_MessageCounter.signal);
        msg.FCM_FRM_3_MessageCounter = msg.FCM_FRM_3_MessageCounter * factor + offset;
        factor = FCM_FRM_3_CRC.factor;
        offset = FCM_FRM_3_CRC.offset;
        msg.FCM_FRM_3_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_3_CRC)>::type*>(&FCM_FRM_3_CRC.signal);
        msg.FCM_FRM_3_CRC = msg.FCM_FRM_3_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_FRM_3_MSG can_struct;
        CanParser2CanStruct_FCM_FRM_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_FRM_3_MSGMsg>();
        Struct2Proto_FCM_FRM_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_frm_3") != nullptr) {
            DFHLOG_I("fcm_frm_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_frm_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_frm_3");
            return false;
         }
    }
};

struct FCM_FRM_5_Parser {
    SignalParser FCM_FRM_5_AEBONOFFSts;

    SignalParser FCM_FRM_5_FCWSnvtySts;

    SignalParser FCM_FRM_5_FCWONOFFSts;

    SignalParser FCM_FRM_5_SCFONOFFSts;

    SignalParser FCM_FRM_5_DAIONOFFSts;

    SignalParser FCM_FRM_5_Resd_1;

    SignalParser FCM_FRM_5_MsgCntr;

    SignalParser FCM_FRM_5_CRC;

    FCM_FRM_5_Parser() {
        FCM_FRM_5_AEBONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_AEBONOFFSts"];
        FCM_FRM_5_FCWSnvtySts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_FCWSnvtySts"];
        FCM_FRM_5_FCWONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_FCWONOFFSts"];
        FCM_FRM_5_SCFONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_SCFONOFFSts"];
        FCM_FRM_5_DAIONOFFSts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_DAIONOFFSts"];
        FCM_FRM_5_Resd_1 = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_Resd_1"];
        FCM_FRM_5_MsgCntr = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_MsgCntr"];
        FCM_FRM_5_CRC = CanConfiguration::Instance().SignalParsers()["FCM_FRM_5_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_FRM_5_AEBONOFFSts.Parser(payload);
        FCM_FRM_5_FCWSnvtySts.Parser(payload);
        FCM_FRM_5_FCWONOFFSts.Parser(payload);
        FCM_FRM_5_SCFONOFFSts.Parser(payload);
        FCM_FRM_5_DAIONOFFSts.Parser(payload);
        FCM_FRM_5_Resd_1.Parser(payload);
        FCM_FRM_5_MsgCntr.Parser(payload);
        FCM_FRM_5_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_FRM_5_MSG(FCM_FRM_5_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_FRM_5_AEBONOFFSts.factor;
        offset = FCM_FRM_5_AEBONOFFSts.offset;
        msg.FCM_FRM_5_AEBONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_AEBONOFFSts)>::type*>(&FCM_FRM_5_AEBONOFFSts.signal);
        msg.FCM_FRM_5_AEBONOFFSts = msg.FCM_FRM_5_AEBONOFFSts * factor + offset;
        factor = FCM_FRM_5_FCWSnvtySts.factor;
        offset = FCM_FRM_5_FCWSnvtySts.offset;
        msg.FCM_FRM_5_FCWSnvtySts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_FCWSnvtySts)>::type*>(&FCM_FRM_5_FCWSnvtySts.signal);
        msg.FCM_FRM_5_FCWSnvtySts = msg.FCM_FRM_5_FCWSnvtySts * factor + offset;
        factor = FCM_FRM_5_FCWONOFFSts.factor;
        offset = FCM_FRM_5_FCWONOFFSts.offset;
        msg.FCM_FRM_5_FCWONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_FCWONOFFSts)>::type*>(&FCM_FRM_5_FCWONOFFSts.signal);
        msg.FCM_FRM_5_FCWONOFFSts = msg.FCM_FRM_5_FCWONOFFSts * factor + offset;
        factor = FCM_FRM_5_SCFONOFFSts.factor;
        offset = FCM_FRM_5_SCFONOFFSts.offset;
        msg.FCM_FRM_5_SCFONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_SCFONOFFSts)>::type*>(&FCM_FRM_5_SCFONOFFSts.signal);
        msg.FCM_FRM_5_SCFONOFFSts = msg.FCM_FRM_5_SCFONOFFSts * factor + offset;
        factor = FCM_FRM_5_DAIONOFFSts.factor;
        offset = FCM_FRM_5_DAIONOFFSts.offset;
        msg.FCM_FRM_5_DAIONOFFSts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_DAIONOFFSts)>::type*>(&FCM_FRM_5_DAIONOFFSts.signal);
        msg.FCM_FRM_5_DAIONOFFSts = msg.FCM_FRM_5_DAIONOFFSts * factor + offset;
        factor = FCM_FRM_5_Resd_1.factor;
        offset = FCM_FRM_5_Resd_1.offset;
        msg.FCM_FRM_5_Resd_1 = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_Resd_1)>::type*>(&FCM_FRM_5_Resd_1.signal);
        msg.FCM_FRM_5_Resd_1 = msg.FCM_FRM_5_Resd_1 * factor + offset;
        factor = FCM_FRM_5_MsgCntr.factor;
        offset = FCM_FRM_5_MsgCntr.offset;
        msg.FCM_FRM_5_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_MsgCntr)>::type*>(&FCM_FRM_5_MsgCntr.signal);
        msg.FCM_FRM_5_MsgCntr = msg.FCM_FRM_5_MsgCntr * factor + offset;
        factor = FCM_FRM_5_CRC.factor;
        offset = FCM_FRM_5_CRC.offset;
        msg.FCM_FRM_5_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_5_CRC)>::type*>(&FCM_FRM_5_CRC.signal);
        msg.FCM_FRM_5_CRC = msg.FCM_FRM_5_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_FRM_5_MSG can_struct;
        CanParser2CanStruct_FCM_FRM_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_FRM_5_MSGMsg>();
        Struct2Proto_FCM_FRM_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_frm_5") != nullptr) {
            DFHLOG_I("fcm_frm_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_frm_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_frm_5");
            return false;
         }
    }
};

struct FCM_FRM_6_Parser {
    SignalParser FCM_FRM_6_Textinfo_Info;

    SignalParser FCM_FRM_6_TextinfoWarn;

    SignalParser FCM_FRM_6_TimeGapSetICM;

    SignalParser FCM_FRM_6_SCF_PopoverReq;

    SignalParser FCM_FRM_6_SCF_SpdLimSts;

    SignalParser FCM_FRM_6_SCF_SpdLimUnit;

    SignalParser FCM_FRM_6_DrvrCfmSCFDispFb;

    SignalParser FCM_FRM_6_DistanceWarning;

    SignalParser FCM_FRM_6_FCW_preWarning;

    SignalParser FCM_FRM_6_TakeOverReq;

    SignalParser FCM_FRM_6_FCWMode;

    SignalParser FCM_FRM_6_AEBMode;

    SignalParser FCM_FRM_6_AEBDecCtrlRequest;

    SignalParser FCM_FRM_6_HMI_Indicator;

    SignalParser FCM_FRM_6_ACCMode;

    SignalParser FCM_FRM_6_VSetDis;

    SignalParser FCM_FRM_6_MsgCntr;

    SignalParser FCM_FRM_6_CRC;

    FCM_FRM_6_Parser() {
        FCM_FRM_6_Textinfo_Info = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_Textinfo_Info"];
        FCM_FRM_6_TextinfoWarn = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_TextinfoWarn"];
        FCM_FRM_6_TimeGapSetICM = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_TimeGapSetICM"];
        FCM_FRM_6_SCF_PopoverReq = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_SCF_PopoverReq"];
        FCM_FRM_6_SCF_SpdLimSts = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_SCF_SpdLimSts"];
        FCM_FRM_6_SCF_SpdLimUnit = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_SCF_SpdLimUnit"];
        FCM_FRM_6_DrvrCfmSCFDispFb = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_DrvrCfmSCFDispFb"];
        FCM_FRM_6_DistanceWarning = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_DistanceWarning"];
        FCM_FRM_6_FCW_preWarning = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_FCW_preWarning"];
        FCM_FRM_6_TakeOverReq = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_TakeOverReq"];
        FCM_FRM_6_FCWMode = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_FCWMode"];
        FCM_FRM_6_AEBMode = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_AEBMode"];
        FCM_FRM_6_AEBDecCtrlRequest = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_AEBDecCtrlRequest"];
        FCM_FRM_6_HMI_Indicator = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_HMI_Indicator"];
        FCM_FRM_6_ACCMode = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_ACCMode"];
        FCM_FRM_6_VSetDis = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_VSetDis"];
        FCM_FRM_6_MsgCntr = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_MsgCntr"];
        FCM_FRM_6_CRC = CanConfiguration::Instance().SignalParsers()["FCM_FRM_6_CRC"];
    }

    void Parser(uint8_t* payload){
        FCM_FRM_6_Textinfo_Info.Parser(payload);
        FCM_FRM_6_TextinfoWarn.Parser(payload);
        FCM_FRM_6_TimeGapSetICM.Parser(payload);
        FCM_FRM_6_SCF_PopoverReq.Parser(payload);
        FCM_FRM_6_SCF_SpdLimSts.Parser(payload);
        FCM_FRM_6_SCF_SpdLimUnit.Parser(payload);
        FCM_FRM_6_DrvrCfmSCFDispFb.Parser(payload);
        FCM_FRM_6_DistanceWarning.Parser(payload);
        FCM_FRM_6_FCW_preWarning.Parser(payload);
        FCM_FRM_6_TakeOverReq.Parser(payload);
        FCM_FRM_6_FCWMode.Parser(payload);
        FCM_FRM_6_AEBMode.Parser(payload);
        FCM_FRM_6_AEBDecCtrlRequest.Parser(payload);
        FCM_FRM_6_HMI_Indicator.Parser(payload);
        FCM_FRM_6_ACCMode.Parser(payload);
        FCM_FRM_6_VSetDis.Parser(payload);
        FCM_FRM_6_MsgCntr.Parser(payload);
        FCM_FRM_6_CRC.Parser(payload);
    }

    void CanParser2CanStruct_FCM_FRM_6_MSG(FCM_FRM_6_MSG& msg) {
        double factor;
        double offset;
        factor = FCM_FRM_6_Textinfo_Info.factor;
        offset = FCM_FRM_6_Textinfo_Info.offset;
        msg.FCM_FRM_6_Textinfo_Info = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_Textinfo_Info)>::type*>(&FCM_FRM_6_Textinfo_Info.signal);
        msg.FCM_FRM_6_Textinfo_Info = msg.FCM_FRM_6_Textinfo_Info * factor + offset;
        factor = FCM_FRM_6_TextinfoWarn.factor;
        offset = FCM_FRM_6_TextinfoWarn.offset;
        msg.FCM_FRM_6_TextinfoWarn = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_TextinfoWarn)>::type*>(&FCM_FRM_6_TextinfoWarn.signal);
        msg.FCM_FRM_6_TextinfoWarn = msg.FCM_FRM_6_TextinfoWarn * factor + offset;
        factor = FCM_FRM_6_TimeGapSetICM.factor;
        offset = FCM_FRM_6_TimeGapSetICM.offset;
        msg.FCM_FRM_6_TimeGapSetICM = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_TimeGapSetICM)>::type*>(&FCM_FRM_6_TimeGapSetICM.signal);
        msg.FCM_FRM_6_TimeGapSetICM = msg.FCM_FRM_6_TimeGapSetICM * factor + offset;
        factor = FCM_FRM_6_SCF_PopoverReq.factor;
        offset = FCM_FRM_6_SCF_PopoverReq.offset;
        msg.FCM_FRM_6_SCF_PopoverReq = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_SCF_PopoverReq)>::type*>(&FCM_FRM_6_SCF_PopoverReq.signal);
        msg.FCM_FRM_6_SCF_PopoverReq = msg.FCM_FRM_6_SCF_PopoverReq * factor + offset;
        factor = FCM_FRM_6_SCF_SpdLimSts.factor;
        offset = FCM_FRM_6_SCF_SpdLimSts.offset;
        msg.FCM_FRM_6_SCF_SpdLimSts = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_SCF_SpdLimSts)>::type*>(&FCM_FRM_6_SCF_SpdLimSts.signal);
        msg.FCM_FRM_6_SCF_SpdLimSts = msg.FCM_FRM_6_SCF_SpdLimSts * factor + offset;
        factor = FCM_FRM_6_SCF_SpdLimUnit.factor;
        offset = FCM_FRM_6_SCF_SpdLimUnit.offset;
        msg.FCM_FRM_6_SCF_SpdLimUnit = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_SCF_SpdLimUnit)>::type*>(&FCM_FRM_6_SCF_SpdLimUnit.signal);
        msg.FCM_FRM_6_SCF_SpdLimUnit = msg.FCM_FRM_6_SCF_SpdLimUnit * factor + offset;
        factor = FCM_FRM_6_DrvrCfmSCFDispFb.factor;
        offset = FCM_FRM_6_DrvrCfmSCFDispFb.offset;
        msg.FCM_FRM_6_DrvrCfmSCFDispFb = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_DrvrCfmSCFDispFb)>::type*>(&FCM_FRM_6_DrvrCfmSCFDispFb.signal);
        msg.FCM_FRM_6_DrvrCfmSCFDispFb = msg.FCM_FRM_6_DrvrCfmSCFDispFb * factor + offset;
        factor = FCM_FRM_6_DistanceWarning.factor;
        offset = FCM_FRM_6_DistanceWarning.offset;
        msg.FCM_FRM_6_DistanceWarning = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_DistanceWarning)>::type*>(&FCM_FRM_6_DistanceWarning.signal);
        msg.FCM_FRM_6_DistanceWarning = msg.FCM_FRM_6_DistanceWarning * factor + offset;
        factor = FCM_FRM_6_FCW_preWarning.factor;
        offset = FCM_FRM_6_FCW_preWarning.offset;
        msg.FCM_FRM_6_FCW_preWarning = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_FCW_preWarning)>::type*>(&FCM_FRM_6_FCW_preWarning.signal);
        msg.FCM_FRM_6_FCW_preWarning = msg.FCM_FRM_6_FCW_preWarning * factor + offset;
        factor = FCM_FRM_6_TakeOverReq.factor;
        offset = FCM_FRM_6_TakeOverReq.offset;
        msg.FCM_FRM_6_TakeOverReq = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_TakeOverReq)>::type*>(&FCM_FRM_6_TakeOverReq.signal);
        msg.FCM_FRM_6_TakeOverReq = msg.FCM_FRM_6_TakeOverReq * factor + offset;
        factor = FCM_FRM_6_FCWMode.factor;
        offset = FCM_FRM_6_FCWMode.offset;
        msg.FCM_FRM_6_FCWMode = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_FCWMode)>::type*>(&FCM_FRM_6_FCWMode.signal);
        msg.FCM_FRM_6_FCWMode = msg.FCM_FRM_6_FCWMode * factor + offset;
        factor = FCM_FRM_6_AEBMode.factor;
        offset = FCM_FRM_6_AEBMode.offset;
        msg.FCM_FRM_6_AEBMode = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_AEBMode)>::type*>(&FCM_FRM_6_AEBMode.signal);
        msg.FCM_FRM_6_AEBMode = msg.FCM_FRM_6_AEBMode * factor + offset;
        factor = FCM_FRM_6_AEBDecCtrlRequest.factor;
        offset = FCM_FRM_6_AEBDecCtrlRequest.offset;
        msg.FCM_FRM_6_AEBDecCtrlRequest = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_AEBDecCtrlRequest)>::type*>(&FCM_FRM_6_AEBDecCtrlRequest.signal);
        msg.FCM_FRM_6_AEBDecCtrlRequest = msg.FCM_FRM_6_AEBDecCtrlRequest * factor + offset;
        factor = FCM_FRM_6_HMI_Indicator.factor;
        offset = FCM_FRM_6_HMI_Indicator.offset;
        msg.FCM_FRM_6_HMI_Indicator = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_HMI_Indicator)>::type*>(&FCM_FRM_6_HMI_Indicator.signal);
        msg.FCM_FRM_6_HMI_Indicator = msg.FCM_FRM_6_HMI_Indicator * factor + offset;
        factor = FCM_FRM_6_ACCMode.factor;
        offset = FCM_FRM_6_ACCMode.offset;
        msg.FCM_FRM_6_ACCMode = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_ACCMode)>::type*>(&FCM_FRM_6_ACCMode.signal);
        msg.FCM_FRM_6_ACCMode = msg.FCM_FRM_6_ACCMode * factor + offset;
        factor = FCM_FRM_6_VSetDis.factor;
        offset = FCM_FRM_6_VSetDis.offset;
        msg.FCM_FRM_6_VSetDis = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_VSetDis)>::type*>(&FCM_FRM_6_VSetDis.signal);
        msg.FCM_FRM_6_VSetDis = msg.FCM_FRM_6_VSetDis * factor + offset;
        factor = FCM_FRM_6_MsgCntr.factor;
        offset = FCM_FRM_6_MsgCntr.offset;
        msg.FCM_FRM_6_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_MsgCntr)>::type*>(&FCM_FRM_6_MsgCntr.signal);
        msg.FCM_FRM_6_MsgCntr = msg.FCM_FRM_6_MsgCntr * factor + offset;
        factor = FCM_FRM_6_CRC.factor;
        offset = FCM_FRM_6_CRC.offset;
        msg.FCM_FRM_6_CRC = *reinterpret_cast<std::decay<decltype(msg.FCM_FRM_6_CRC)>::type*>(&FCM_FRM_6_CRC.signal);
        msg.FCM_FRM_6_CRC = msg.FCM_FRM_6_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        FCM_FRM_6_MSG can_struct;
        CanParser2CanStruct_FCM_FRM_6_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::FCM_FRM_6_MSGMsg>();
        Struct2Proto_FCM_FRM_6_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("fcm_frm_6") != nullptr) {
            DFHLOG_I("fcm_frm_6");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("fcm_frm_6")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port fcm_frm_6");
            return false;
         }
    }
};

struct AVM_2_Parser {
    SignalParser AVMFaultStatusCameraFront;

    SignalParser AVMFaultStatusCameraLeft;

    SignalParser AVMFaultStatusCameraRear;

    SignalParser AVMFaultStatusCameraRight;

    SignalParser AVMStatusFault;

    SignalParser AVM_2_Reserved1;

    AVM_2_Parser() {
        AVMFaultStatusCameraFront = CanConfiguration::Instance().SignalParsers()["AVMFaultStatusCameraFront"];
        AVMFaultStatusCameraLeft = CanConfiguration::Instance().SignalParsers()["AVMFaultStatusCameraLeft"];
        AVMFaultStatusCameraRear = CanConfiguration::Instance().SignalParsers()["AVMFaultStatusCameraRear"];
        AVMFaultStatusCameraRight = CanConfiguration::Instance().SignalParsers()["AVMFaultStatusCameraRight"];
        AVMStatusFault = CanConfiguration::Instance().SignalParsers()["AVMStatusFault"];
        AVM_2_Reserved1 = CanConfiguration::Instance().SignalParsers()["AVM_2_Reserved1"];
    }

    void Parser(uint8_t* payload){
        AVMFaultStatusCameraFront.Parser(payload);
        AVMFaultStatusCameraLeft.Parser(payload);
        AVMFaultStatusCameraRear.Parser(payload);
        AVMFaultStatusCameraRight.Parser(payload);
        AVMStatusFault.Parser(payload);
        AVM_2_Reserved1.Parser(payload);
    }

    void CanParser2CanStruct_AVM_2_MSG(AVM_2_MSG& msg) {
        double factor;
        double offset;
        factor = AVMFaultStatusCameraFront.factor;
        offset = AVMFaultStatusCameraFront.offset;
        msg.AVMFaultStatusCameraFront = *reinterpret_cast<std::decay<decltype(msg.AVMFaultStatusCameraFront)>::type*>(&AVMFaultStatusCameraFront.signal);
        msg.AVMFaultStatusCameraFront = msg.AVMFaultStatusCameraFront * factor + offset;
        factor = AVMFaultStatusCameraLeft.factor;
        offset = AVMFaultStatusCameraLeft.offset;
        msg.AVMFaultStatusCameraLeft = *reinterpret_cast<std::decay<decltype(msg.AVMFaultStatusCameraLeft)>::type*>(&AVMFaultStatusCameraLeft.signal);
        msg.AVMFaultStatusCameraLeft = msg.AVMFaultStatusCameraLeft * factor + offset;
        factor = AVMFaultStatusCameraRear.factor;
        offset = AVMFaultStatusCameraRear.offset;
        msg.AVMFaultStatusCameraRear = *reinterpret_cast<std::decay<decltype(msg.AVMFaultStatusCameraRear)>::type*>(&AVMFaultStatusCameraRear.signal);
        msg.AVMFaultStatusCameraRear = msg.AVMFaultStatusCameraRear * factor + offset;
        factor = AVMFaultStatusCameraRight.factor;
        offset = AVMFaultStatusCameraRight.offset;
        msg.AVMFaultStatusCameraRight = *reinterpret_cast<std::decay<decltype(msg.AVMFaultStatusCameraRight)>::type*>(&AVMFaultStatusCameraRight.signal);
        msg.AVMFaultStatusCameraRight = msg.AVMFaultStatusCameraRight * factor + offset;
        factor = AVMStatusFault.factor;
        offset = AVMStatusFault.offset;
        msg.AVMStatusFault = *reinterpret_cast<std::decay<decltype(msg.AVMStatusFault)>::type*>(&AVMStatusFault.signal);
        msg.AVMStatusFault = msg.AVMStatusFault * factor + offset;
        factor = AVM_2_Reserved1.factor;
        offset = AVM_2_Reserved1.offset;
        msg.AVM_2_Reserved1 = *reinterpret_cast<std::decay<decltype(msg.AVM_2_Reserved1)>::type*>(&AVM_2_Reserved1.signal);
        msg.AVM_2_Reserved1 = msg.AVM_2_Reserved1 * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        AVM_2_MSG can_struct;
        CanParser2CanStruct_AVM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::AVM_2_MSGMsg>();
        Struct2Proto_AVM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("avm_2") != nullptr) {
            DFHLOG_I("avm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("avm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port avm_2");
            return false;
         }
    }
};

struct AVM_3_Parser {
    SignalParser AVMDisplaySts;

    SignalParser AVM_3_IHUTTS;

    SignalParser HPA_Subscribe_Status;

    SignalParser AVM_3_IHUTTSExtend;

    SignalParser HPA_BeamReq;

    SignalParser AVMFeedbackSts_RemoteMode;

    SignalParser AVM_FactoryMode;

    SignalParser HPA_IHU_Audio_Learn_Tips;

    SignalParser REQ_AVMDisp_1;

    SignalParser HPA_IHU_Audio_HPA_status;

    AVM_3_Parser() {
        AVMDisplaySts = CanConfiguration::Instance().SignalParsers()["AVMDisplaySts"];
        AVM_3_IHUTTS = CanConfiguration::Instance().SignalParsers()["AVM_3_IHUTTS"];
        HPA_Subscribe_Status = CanConfiguration::Instance().SignalParsers()["HPA_Subscribe_Status"];
        AVM_3_IHUTTSExtend = CanConfiguration::Instance().SignalParsers()["AVM_3_IHUTTSExtend"];
        HPA_BeamReq = CanConfiguration::Instance().SignalParsers()["HPA_BeamReq"];
        AVMFeedbackSts_RemoteMode = CanConfiguration::Instance().SignalParsers()["AVMFeedbackSts_RemoteMode"];
        AVM_FactoryMode = CanConfiguration::Instance().SignalParsers()["AVM_FactoryMode"];
        HPA_IHU_Audio_Learn_Tips = CanConfiguration::Instance().SignalParsers()["HPA_IHU_Audio_Learn_Tips"];
        REQ_AVMDisp_1 = CanConfiguration::Instance().SignalParsers()["REQ_AVMDisp_1"];
        HPA_IHU_Audio_HPA_status = CanConfiguration::Instance().SignalParsers()["HPA_IHU_Audio_HPA_status"];
    }

    void Parser(uint8_t* payload){
        AVMDisplaySts.Parser(payload);
        AVM_3_IHUTTS.Parser(payload);
        HPA_Subscribe_Status.Parser(payload);
        AVM_3_IHUTTSExtend.Parser(payload);
        HPA_BeamReq.Parser(payload);
        AVMFeedbackSts_RemoteMode.Parser(payload);
        AVM_FactoryMode.Parser(payload);
        HPA_IHU_Audio_Learn_Tips.Parser(payload);
        REQ_AVMDisp_1.Parser(payload);
        HPA_IHU_Audio_HPA_status.Parser(payload);
    }

    void CanParser2CanStruct_AVM_3_MSG(AVM_3_MSG& msg) {
        double factor;
        double offset;
        factor = AVMDisplaySts.factor;
        offset = AVMDisplaySts.offset;
        msg.AVMDisplaySts = *reinterpret_cast<std::decay<decltype(msg.AVMDisplaySts)>::type*>(&AVMDisplaySts.signal);
        msg.AVMDisplaySts = msg.AVMDisplaySts * factor + offset;
        factor = AVM_3_IHUTTS.factor;
        offset = AVM_3_IHUTTS.offset;
        msg.AVM_3_IHUTTS = *reinterpret_cast<std::decay<decltype(msg.AVM_3_IHUTTS)>::type*>(&AVM_3_IHUTTS.signal);
        msg.AVM_3_IHUTTS = msg.AVM_3_IHUTTS * factor + offset;
        factor = HPA_Subscribe_Status.factor;
        offset = HPA_Subscribe_Status.offset;
        msg.HPA_Subscribe_Status = *reinterpret_cast<std::decay<decltype(msg.HPA_Subscribe_Status)>::type*>(&HPA_Subscribe_Status.signal);
        msg.HPA_Subscribe_Status = msg.HPA_Subscribe_Status * factor + offset;
        factor = AVM_3_IHUTTSExtend.factor;
        offset = AVM_3_IHUTTSExtend.offset;
        msg.AVM_3_IHUTTSExtend = *reinterpret_cast<std::decay<decltype(msg.AVM_3_IHUTTSExtend)>::type*>(&AVM_3_IHUTTSExtend.signal);
        msg.AVM_3_IHUTTSExtend = msg.AVM_3_IHUTTSExtend * factor + offset;
        factor = HPA_BeamReq.factor;
        offset = HPA_BeamReq.offset;
        msg.HPA_BeamReq = *reinterpret_cast<std::decay<decltype(msg.HPA_BeamReq)>::type*>(&HPA_BeamReq.signal);
        msg.HPA_BeamReq = msg.HPA_BeamReq * factor + offset;
        factor = AVMFeedbackSts_RemoteMode.factor;
        offset = AVMFeedbackSts_RemoteMode.offset;
        msg.AVMFeedbackSts_RemoteMode = *reinterpret_cast<std::decay<decltype(msg.AVMFeedbackSts_RemoteMode)>::type*>(&AVMFeedbackSts_RemoteMode.signal);
        msg.AVMFeedbackSts_RemoteMode = msg.AVMFeedbackSts_RemoteMode * factor + offset;
        factor = AVM_FactoryMode.factor;
        offset = AVM_FactoryMode.offset;
        msg.AVM_FactoryMode = *reinterpret_cast<std::decay<decltype(msg.AVM_FactoryMode)>::type*>(&AVM_FactoryMode.signal);
        msg.AVM_FactoryMode = msg.AVM_FactoryMode * factor + offset;
        factor = HPA_IHU_Audio_Learn_Tips.factor;
        offset = HPA_IHU_Audio_Learn_Tips.offset;
        msg.HPA_IHU_Audio_Learn_Tips = *reinterpret_cast<std::decay<decltype(msg.HPA_IHU_Audio_Learn_Tips)>::type*>(&HPA_IHU_Audio_Learn_Tips.signal);
        msg.HPA_IHU_Audio_Learn_Tips = msg.HPA_IHU_Audio_Learn_Tips * factor + offset;
        factor = REQ_AVMDisp_1.factor;
        offset = REQ_AVMDisp_1.offset;
        msg.REQ_AVMDisp_1 = *reinterpret_cast<std::decay<decltype(msg.REQ_AVMDisp_1)>::type*>(&REQ_AVMDisp_1.signal);
        msg.REQ_AVMDisp_1 = msg.REQ_AVMDisp_1 * factor + offset;
        factor = HPA_IHU_Audio_HPA_status.factor;
        offset = HPA_IHU_Audio_HPA_status.offset;
        msg.HPA_IHU_Audio_HPA_status = *reinterpret_cast<std::decay<decltype(msg.HPA_IHU_Audio_HPA_status)>::type*>(&HPA_IHU_Audio_HPA_status.signal);
        msg.HPA_IHU_Audio_HPA_status = msg.HPA_IHU_Audio_HPA_status * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        AVM_3_MSG can_struct;
        CanParser2CanStruct_AVM_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::AVM_3_MSGMsg>();
        Struct2Proto_AVM_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("avm_3") != nullptr) {
            DFHLOG_I("avm_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("avm_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port avm_3");
            return false;
         }
    }
};

struct IDCU_FCM_1_Parser {
    SignalParser IDCU_1_AmbLi;

    SignalParser IDCU_1_HozlPosnRi;

    SignalParser IDCU_1_HozlPosnLe;

    SignalParser IDCU_1_ObjN1Dst;

    SignalParser IDCU_1_reserved_1;

    SignalParser IDCU_1_ObjN1_Type;

    SignalParser IDCU_1_reserved_2;

    SignalParser IDCU_1_MsgCntr;

    SignalParser IDCU_1_CRC;

    IDCU_FCM_1_Parser() {
        IDCU_1_AmbLi = CanConfiguration::Instance().SignalParsers()["IDCU_1_AmbLi"];
        IDCU_1_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_1_HozlPosnRi"];
        IDCU_1_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_1_HozlPosnLe"];
        IDCU_1_ObjN1Dst = CanConfiguration::Instance().SignalParsers()["IDCU_1_ObjN1Dst"];
        IDCU_1_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_1_reserved_1"];
        IDCU_1_ObjN1_Type = CanConfiguration::Instance().SignalParsers()["IDCU_1_ObjN1_Type"];
        IDCU_1_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_1_reserved_2"];
        IDCU_1_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_1_MsgCntr"];
        IDCU_1_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_1_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_1_AmbLi.Parser(payload);
        IDCU_1_HozlPosnRi.Parser(payload);
        IDCU_1_HozlPosnLe.Parser(payload);
        IDCU_1_ObjN1Dst.Parser(payload);
        IDCU_1_reserved_1.Parser(payload);
        IDCU_1_ObjN1_Type.Parser(payload);
        IDCU_1_reserved_2.Parser(payload);
        IDCU_1_MsgCntr.Parser(payload);
        IDCU_1_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_1_MSG(IDCU_FCM_1_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_1_AmbLi.factor;
        offset = IDCU_1_AmbLi.offset;
        msg.IDCU_1_AmbLi = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_AmbLi)>::type*>(&IDCU_1_AmbLi.signal);
        msg.IDCU_1_AmbLi = msg.IDCU_1_AmbLi * factor + offset;
        factor = IDCU_1_HozlPosnRi.factor;
        offset = IDCU_1_HozlPosnRi.offset;
        msg.IDCU_1_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_HozlPosnRi)>::type*>(&IDCU_1_HozlPosnRi.signal);
        msg.IDCU_1_HozlPosnRi = msg.IDCU_1_HozlPosnRi * factor + offset;
        factor = IDCU_1_HozlPosnLe.factor;
        offset = IDCU_1_HozlPosnLe.offset;
        msg.IDCU_1_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_HozlPosnLe)>::type*>(&IDCU_1_HozlPosnLe.signal);
        msg.IDCU_1_HozlPosnLe = msg.IDCU_1_HozlPosnLe * factor + offset;
        factor = IDCU_1_ObjN1Dst.factor;
        offset = IDCU_1_ObjN1Dst.offset;
        msg.IDCU_1_ObjN1Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_ObjN1Dst)>::type*>(&IDCU_1_ObjN1Dst.signal);
        msg.IDCU_1_ObjN1Dst = msg.IDCU_1_ObjN1Dst * factor + offset;
        factor = IDCU_1_reserved_1.factor;
        offset = IDCU_1_reserved_1.offset;
        msg.IDCU_1_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_reserved_1)>::type*>(&IDCU_1_reserved_1.signal);
        msg.IDCU_1_reserved_1 = msg.IDCU_1_reserved_1 * factor + offset;
        factor = IDCU_1_ObjN1_Type.factor;
        offset = IDCU_1_ObjN1_Type.offset;
        msg.IDCU_1_ObjN1_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_ObjN1_Type)>::type*>(&IDCU_1_ObjN1_Type.signal);
        msg.IDCU_1_ObjN1_Type = msg.IDCU_1_ObjN1_Type * factor + offset;
        factor = IDCU_1_reserved_2.factor;
        offset = IDCU_1_reserved_2.offset;
        msg.IDCU_1_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_reserved_2)>::type*>(&IDCU_1_reserved_2.signal);
        msg.IDCU_1_reserved_2 = msg.IDCU_1_reserved_2 * factor + offset;
        factor = IDCU_1_MsgCntr.factor;
        offset = IDCU_1_MsgCntr.offset;
        msg.IDCU_1_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_MsgCntr)>::type*>(&IDCU_1_MsgCntr.signal);
        msg.IDCU_1_MsgCntr = msg.IDCU_1_MsgCntr * factor + offset;
        factor = IDCU_1_CRC.factor;
        offset = IDCU_1_CRC.offset;
        msg.IDCU_1_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_CRC)>::type*>(&IDCU_1_CRC.signal);
        msg.IDCU_1_CRC = msg.IDCU_1_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_1_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_1_MSGMsg>();
        Struct2Proto_IDCU_FCM_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_1") != nullptr) {
            DFHLOG_I("idcu_fcm_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_1");
            return false;
         }
    }
};

struct IDCU_FCM_2_Parser {
    SignalParser IDCU_2_FCMStForADB;

    SignalParser IDCU_2_reserved_1;

    SignalParser IDCU_2_HozlPosnRi;

    SignalParser IDCU_2_HozlPosnLe;

    SignalParser IDCU_2_ObjN1Dst;

    SignalParser IDCU_2_reserved_2;

    SignalParser IDCU_2_ObjN2_Type;

    SignalParser IDCU_2_reserved_3;

    SignalParser IDCU_2_MsgCntr;

    SignalParser IDCU_2_CRC;

    IDCU_FCM_2_Parser() {
        IDCU_2_FCMStForADB = CanConfiguration::Instance().SignalParsers()["IDCU_2_FCMStForADB"];
        IDCU_2_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_2_reserved_1"];
        IDCU_2_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_2_HozlPosnRi"];
        IDCU_2_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_2_HozlPosnLe"];
        IDCU_2_ObjN1Dst = CanConfiguration::Instance().SignalParsers()["IDCU_2_ObjN1Dst"];
        IDCU_2_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_2_reserved_2"];
        IDCU_2_ObjN2_Type = CanConfiguration::Instance().SignalParsers()["IDCU_2_ObjN2_Type"];
        IDCU_2_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_2_reserved_3"];
        IDCU_2_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_2_MsgCntr"];
        IDCU_2_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_2_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_2_FCMStForADB.Parser(payload);
        IDCU_2_reserved_1.Parser(payload);
        IDCU_2_HozlPosnRi.Parser(payload);
        IDCU_2_HozlPosnLe.Parser(payload);
        IDCU_2_ObjN1Dst.Parser(payload);
        IDCU_2_reserved_2.Parser(payload);
        IDCU_2_ObjN2_Type.Parser(payload);
        IDCU_2_reserved_3.Parser(payload);
        IDCU_2_MsgCntr.Parser(payload);
        IDCU_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_2_MSG(IDCU_FCM_2_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_2_FCMStForADB.factor;
        offset = IDCU_2_FCMStForADB.offset;
        msg.IDCU_2_FCMStForADB = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_FCMStForADB)>::type*>(&IDCU_2_FCMStForADB.signal);
        msg.IDCU_2_FCMStForADB = msg.IDCU_2_FCMStForADB * factor + offset;
        factor = IDCU_2_reserved_1.factor;
        offset = IDCU_2_reserved_1.offset;
        msg.IDCU_2_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_reserved_1)>::type*>(&IDCU_2_reserved_1.signal);
        msg.IDCU_2_reserved_1 = msg.IDCU_2_reserved_1 * factor + offset;
        factor = IDCU_2_HozlPosnRi.factor;
        offset = IDCU_2_HozlPosnRi.offset;
        msg.IDCU_2_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_HozlPosnRi)>::type*>(&IDCU_2_HozlPosnRi.signal);
        msg.IDCU_2_HozlPosnRi = msg.IDCU_2_HozlPosnRi * factor + offset;
        factor = IDCU_2_HozlPosnLe.factor;
        offset = IDCU_2_HozlPosnLe.offset;
        msg.IDCU_2_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_HozlPosnLe)>::type*>(&IDCU_2_HozlPosnLe.signal);
        msg.IDCU_2_HozlPosnLe = msg.IDCU_2_HozlPosnLe * factor + offset;
        factor = IDCU_2_ObjN1Dst.factor;
        offset = IDCU_2_ObjN1Dst.offset;
        msg.IDCU_2_ObjN1Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_ObjN1Dst)>::type*>(&IDCU_2_ObjN1Dst.signal);
        msg.IDCU_2_ObjN1Dst = msg.IDCU_2_ObjN1Dst * factor + offset;
        factor = IDCU_2_reserved_2.factor;
        offset = IDCU_2_reserved_2.offset;
        msg.IDCU_2_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_reserved_2)>::type*>(&IDCU_2_reserved_2.signal);
        msg.IDCU_2_reserved_2 = msg.IDCU_2_reserved_2 * factor + offset;
        factor = IDCU_2_ObjN2_Type.factor;
        offset = IDCU_2_ObjN2_Type.offset;
        msg.IDCU_2_ObjN2_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_ObjN2_Type)>::type*>(&IDCU_2_ObjN2_Type.signal);
        msg.IDCU_2_ObjN2_Type = msg.IDCU_2_ObjN2_Type * factor + offset;
        factor = IDCU_2_reserved_3.factor;
        offset = IDCU_2_reserved_3.offset;
        msg.IDCU_2_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_reserved_3)>::type*>(&IDCU_2_reserved_3.signal);
        msg.IDCU_2_reserved_3 = msg.IDCU_2_reserved_3 * factor + offset;
        factor = IDCU_2_MsgCntr.factor;
        offset = IDCU_2_MsgCntr.offset;
        msg.IDCU_2_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_MsgCntr)>::type*>(&IDCU_2_MsgCntr.signal);
        msg.IDCU_2_MsgCntr = msg.IDCU_2_MsgCntr * factor + offset;
        factor = IDCU_2_CRC.factor;
        offset = IDCU_2_CRC.offset;
        msg.IDCU_2_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_2_CRC)>::type*>(&IDCU_2_CRC.signal);
        msg.IDCU_2_CRC = msg.IDCU_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_2_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_2_MSGMsg>();
        Struct2Proto_IDCU_FCM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_2") != nullptr) {
            DFHLOG_I("idcu_fcm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_2");
            return false;
         }
    }
};

struct IDCU_FCM_3_Parser {
    SignalParser IDCU_3_reserved_1;

    SignalParser IDCU_3_HozlPosnRi;

    SignalParser IDCU_3_HozlPosnLe;

    SignalParser IDCU_3_ObjN3Dst;

    SignalParser IDCU_3_reserved_2;

    SignalParser IDCU_3_ObjN3_Type;

    SignalParser IDCU_3_reserved_3;

    SignalParser IDCU_3_MsgCntr;

    SignalParser IDCU_3_CRC;

    IDCU_FCM_3_Parser() {
        IDCU_3_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_3_reserved_1"];
        IDCU_3_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_3_HozlPosnRi"];
        IDCU_3_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_3_HozlPosnLe"];
        IDCU_3_ObjN3Dst = CanConfiguration::Instance().SignalParsers()["IDCU_3_ObjN3Dst"];
        IDCU_3_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_3_reserved_2"];
        IDCU_3_ObjN3_Type = CanConfiguration::Instance().SignalParsers()["IDCU_3_ObjN3_Type"];
        IDCU_3_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_3_reserved_3"];
        IDCU_3_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_3_MsgCntr"];
        IDCU_3_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_3_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_3_reserved_1.Parser(payload);
        IDCU_3_HozlPosnRi.Parser(payload);
        IDCU_3_HozlPosnLe.Parser(payload);
        IDCU_3_ObjN3Dst.Parser(payload);
        IDCU_3_reserved_2.Parser(payload);
        IDCU_3_ObjN3_Type.Parser(payload);
        IDCU_3_reserved_3.Parser(payload);
        IDCU_3_MsgCntr.Parser(payload);
        IDCU_3_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_3_MSG(IDCU_FCM_3_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_3_reserved_1.factor;
        offset = IDCU_3_reserved_1.offset;
        msg.IDCU_3_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_reserved_1)>::type*>(&IDCU_3_reserved_1.signal);
        msg.IDCU_3_reserved_1 = msg.IDCU_3_reserved_1 * factor + offset;
        factor = IDCU_3_HozlPosnRi.factor;
        offset = IDCU_3_HozlPosnRi.offset;
        msg.IDCU_3_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_HozlPosnRi)>::type*>(&IDCU_3_HozlPosnRi.signal);
        msg.IDCU_3_HozlPosnRi = msg.IDCU_3_HozlPosnRi * factor + offset;
        factor = IDCU_3_HozlPosnLe.factor;
        offset = IDCU_3_HozlPosnLe.offset;
        msg.IDCU_3_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_HozlPosnLe)>::type*>(&IDCU_3_HozlPosnLe.signal);
        msg.IDCU_3_HozlPosnLe = msg.IDCU_3_HozlPosnLe * factor + offset;
        factor = IDCU_3_ObjN3Dst.factor;
        offset = IDCU_3_ObjN3Dst.offset;
        msg.IDCU_3_ObjN3Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_ObjN3Dst)>::type*>(&IDCU_3_ObjN3Dst.signal);
        msg.IDCU_3_ObjN3Dst = msg.IDCU_3_ObjN3Dst * factor + offset;
        factor = IDCU_3_reserved_2.factor;
        offset = IDCU_3_reserved_2.offset;
        msg.IDCU_3_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_reserved_2)>::type*>(&IDCU_3_reserved_2.signal);
        msg.IDCU_3_reserved_2 = msg.IDCU_3_reserved_2 * factor + offset;
        factor = IDCU_3_ObjN3_Type.factor;
        offset = IDCU_3_ObjN3_Type.offset;
        msg.IDCU_3_ObjN3_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_ObjN3_Type)>::type*>(&IDCU_3_ObjN3_Type.signal);
        msg.IDCU_3_ObjN3_Type = msg.IDCU_3_ObjN3_Type * factor + offset;
        factor = IDCU_3_reserved_3.factor;
        offset = IDCU_3_reserved_3.offset;
        msg.IDCU_3_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_reserved_3)>::type*>(&IDCU_3_reserved_3.signal);
        msg.IDCU_3_reserved_3 = msg.IDCU_3_reserved_3 * factor + offset;
        factor = IDCU_3_MsgCntr.factor;
        offset = IDCU_3_MsgCntr.offset;
        msg.IDCU_3_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_MsgCntr)>::type*>(&IDCU_3_MsgCntr.signal);
        msg.IDCU_3_MsgCntr = msg.IDCU_3_MsgCntr * factor + offset;
        factor = IDCU_3_CRC.factor;
        offset = IDCU_3_CRC.offset;
        msg.IDCU_3_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_3_CRC)>::type*>(&IDCU_3_CRC.signal);
        msg.IDCU_3_CRC = msg.IDCU_3_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_3_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_3_MSGMsg>();
        Struct2Proto_IDCU_FCM_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_3") != nullptr) {
            DFHLOG_I("idcu_fcm_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_3");
            return false;
         }
    }
};

struct IDCU_FCM_4_Parser {
    SignalParser IDCU_4_reserved_1;

    SignalParser IDCU_4_HozlPosnRi;

    SignalParser IDCU_4_HozlPosnLe;

    SignalParser IDCU_4_ObjN4Dst;

    SignalParser IDCU_4_reserved_2;

    SignalParser IDCU_4_ObjN4_Type;

    SignalParser IDCU_4_reserved_3;

    SignalParser IDCU_4_MsgCntr;

    SignalParser IDCU_4_CRC;

    IDCU_FCM_4_Parser() {
        IDCU_4_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_4_reserved_1"];
        IDCU_4_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_4_HozlPosnRi"];
        IDCU_4_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_4_HozlPosnLe"];
        IDCU_4_ObjN4Dst = CanConfiguration::Instance().SignalParsers()["IDCU_4_ObjN4Dst"];
        IDCU_4_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_4_reserved_2"];
        IDCU_4_ObjN4_Type = CanConfiguration::Instance().SignalParsers()["IDCU_4_ObjN4_Type"];
        IDCU_4_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_4_reserved_3"];
        IDCU_4_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_4_MsgCntr"];
        IDCU_4_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_4_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_4_reserved_1.Parser(payload);
        IDCU_4_HozlPosnRi.Parser(payload);
        IDCU_4_HozlPosnLe.Parser(payload);
        IDCU_4_ObjN4Dst.Parser(payload);
        IDCU_4_reserved_2.Parser(payload);
        IDCU_4_ObjN4_Type.Parser(payload);
        IDCU_4_reserved_3.Parser(payload);
        IDCU_4_MsgCntr.Parser(payload);
        IDCU_4_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_4_MSG(IDCU_FCM_4_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_4_reserved_1.factor;
        offset = IDCU_4_reserved_1.offset;
        msg.IDCU_4_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_reserved_1)>::type*>(&IDCU_4_reserved_1.signal);
        msg.IDCU_4_reserved_1 = msg.IDCU_4_reserved_1 * factor + offset;
        factor = IDCU_4_HozlPosnRi.factor;
        offset = IDCU_4_HozlPosnRi.offset;
        msg.IDCU_4_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_HozlPosnRi)>::type*>(&IDCU_4_HozlPosnRi.signal);
        msg.IDCU_4_HozlPosnRi = msg.IDCU_4_HozlPosnRi * factor + offset;
        factor = IDCU_4_HozlPosnLe.factor;
        offset = IDCU_4_HozlPosnLe.offset;
        msg.IDCU_4_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_HozlPosnLe)>::type*>(&IDCU_4_HozlPosnLe.signal);
        msg.IDCU_4_HozlPosnLe = msg.IDCU_4_HozlPosnLe * factor + offset;
        factor = IDCU_4_ObjN4Dst.factor;
        offset = IDCU_4_ObjN4Dst.offset;
        msg.IDCU_4_ObjN4Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_ObjN4Dst)>::type*>(&IDCU_4_ObjN4Dst.signal);
        msg.IDCU_4_ObjN4Dst = msg.IDCU_4_ObjN4Dst * factor + offset;
        factor = IDCU_4_reserved_2.factor;
        offset = IDCU_4_reserved_2.offset;
        msg.IDCU_4_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_reserved_2)>::type*>(&IDCU_4_reserved_2.signal);
        msg.IDCU_4_reserved_2 = msg.IDCU_4_reserved_2 * factor + offset;
        factor = IDCU_4_ObjN4_Type.factor;
        offset = IDCU_4_ObjN4_Type.offset;
        msg.IDCU_4_ObjN4_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_ObjN4_Type)>::type*>(&IDCU_4_ObjN4_Type.signal);
        msg.IDCU_4_ObjN4_Type = msg.IDCU_4_ObjN4_Type * factor + offset;
        factor = IDCU_4_reserved_3.factor;
        offset = IDCU_4_reserved_3.offset;
        msg.IDCU_4_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_reserved_3)>::type*>(&IDCU_4_reserved_3.signal);
        msg.IDCU_4_reserved_3 = msg.IDCU_4_reserved_3 * factor + offset;
        factor = IDCU_4_MsgCntr.factor;
        offset = IDCU_4_MsgCntr.offset;
        msg.IDCU_4_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_MsgCntr)>::type*>(&IDCU_4_MsgCntr.signal);
        msg.IDCU_4_MsgCntr = msg.IDCU_4_MsgCntr * factor + offset;
        factor = IDCU_4_CRC.factor;
        offset = IDCU_4_CRC.offset;
        msg.IDCU_4_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_4_CRC)>::type*>(&IDCU_4_CRC.signal);
        msg.IDCU_4_CRC = msg.IDCU_4_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_4_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_4_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_4_MSGMsg>();
        Struct2Proto_IDCU_FCM_4_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_4") != nullptr) {
            DFHLOG_I("idcu_fcm_4");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_4")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_4");
            return false;
         }
    }
};

struct IDCU_FCM_5_Parser {
    SignalParser IDCU_5_reserved_1;

    SignalParser IDCU_5_HozlPosnRi;

    SignalParser IDCU_5_HozlPosnLe;

    SignalParser IDCU_5_ObjN5Dst;

    SignalParser IDCU_5_reserved_2;

    SignalParser IDCU_5_ObjN5_Type;

    SignalParser IDCU_5_reserved_3;

    SignalParser IDCU_5_MsgCntr;

    SignalParser IDCU_5_CRC;

    IDCU_FCM_5_Parser() {
        IDCU_5_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_5_reserved_1"];
        IDCU_5_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_5_HozlPosnRi"];
        IDCU_5_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_5_HozlPosnLe"];
        IDCU_5_ObjN5Dst = CanConfiguration::Instance().SignalParsers()["IDCU_5_ObjN5Dst"];
        IDCU_5_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_5_reserved_2"];
        IDCU_5_ObjN5_Type = CanConfiguration::Instance().SignalParsers()["IDCU_5_ObjN5_Type"];
        IDCU_5_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_5_reserved_3"];
        IDCU_5_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_5_MsgCntr"];
        IDCU_5_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_5_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_5_reserved_1.Parser(payload);
        IDCU_5_HozlPosnRi.Parser(payload);
        IDCU_5_HozlPosnLe.Parser(payload);
        IDCU_5_ObjN5Dst.Parser(payload);
        IDCU_5_reserved_2.Parser(payload);
        IDCU_5_ObjN5_Type.Parser(payload);
        IDCU_5_reserved_3.Parser(payload);
        IDCU_5_MsgCntr.Parser(payload);
        IDCU_5_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_5_MSG(IDCU_FCM_5_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_5_reserved_1.factor;
        offset = IDCU_5_reserved_1.offset;
        msg.IDCU_5_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_reserved_1)>::type*>(&IDCU_5_reserved_1.signal);
        msg.IDCU_5_reserved_1 = msg.IDCU_5_reserved_1 * factor + offset;
        factor = IDCU_5_HozlPosnRi.factor;
        offset = IDCU_5_HozlPosnRi.offset;
        msg.IDCU_5_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_HozlPosnRi)>::type*>(&IDCU_5_HozlPosnRi.signal);
        msg.IDCU_5_HozlPosnRi = msg.IDCU_5_HozlPosnRi * factor + offset;
        factor = IDCU_5_HozlPosnLe.factor;
        offset = IDCU_5_HozlPosnLe.offset;
        msg.IDCU_5_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_HozlPosnLe)>::type*>(&IDCU_5_HozlPosnLe.signal);
        msg.IDCU_5_HozlPosnLe = msg.IDCU_5_HozlPosnLe * factor + offset;
        factor = IDCU_5_ObjN5Dst.factor;
        offset = IDCU_5_ObjN5Dst.offset;
        msg.IDCU_5_ObjN5Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_ObjN5Dst)>::type*>(&IDCU_5_ObjN5Dst.signal);
        msg.IDCU_5_ObjN5Dst = msg.IDCU_5_ObjN5Dst * factor + offset;
        factor = IDCU_5_reserved_2.factor;
        offset = IDCU_5_reserved_2.offset;
        msg.IDCU_5_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_reserved_2)>::type*>(&IDCU_5_reserved_2.signal);
        msg.IDCU_5_reserved_2 = msg.IDCU_5_reserved_2 * factor + offset;
        factor = IDCU_5_ObjN5_Type.factor;
        offset = IDCU_5_ObjN5_Type.offset;
        msg.IDCU_5_ObjN5_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_ObjN5_Type)>::type*>(&IDCU_5_ObjN5_Type.signal);
        msg.IDCU_5_ObjN5_Type = msg.IDCU_5_ObjN5_Type * factor + offset;
        factor = IDCU_5_reserved_3.factor;
        offset = IDCU_5_reserved_3.offset;
        msg.IDCU_5_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_reserved_3)>::type*>(&IDCU_5_reserved_3.signal);
        msg.IDCU_5_reserved_3 = msg.IDCU_5_reserved_3 * factor + offset;
        factor = IDCU_5_MsgCntr.factor;
        offset = IDCU_5_MsgCntr.offset;
        msg.IDCU_5_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_MsgCntr)>::type*>(&IDCU_5_MsgCntr.signal);
        msg.IDCU_5_MsgCntr = msg.IDCU_5_MsgCntr * factor + offset;
        factor = IDCU_5_CRC.factor;
        offset = IDCU_5_CRC.offset;
        msg.IDCU_5_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_5_CRC)>::type*>(&IDCU_5_CRC.signal);
        msg.IDCU_5_CRC = msg.IDCU_5_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_5_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_5_MSGMsg>();
        Struct2Proto_IDCU_FCM_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_5") != nullptr) {
            DFHLOG_I("idcu_fcm_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_5");
            return false;
         }
    }
};

struct IDCU_FCM_6_Parser {
    SignalParser IDCU_6_reserved_1;

    SignalParser IDCU_6_HozlPosnRi;

    SignalParser IDCU_6_HozlPosnLe;

    SignalParser IDCU_6_ObjN6Dst;

    SignalParser IDCU_6_reserved_2;

    SignalParser IDCU_6_ObjN6_Type;

    SignalParser IDCU_6_reserved_3;

    SignalParser IDCU_6_MsgCntr;

    SignalParser IDCU_6_CRC;

    IDCU_FCM_6_Parser() {
        IDCU_6_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_6_reserved_1"];
        IDCU_6_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_6_HozlPosnRi"];
        IDCU_6_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_6_HozlPosnLe"];
        IDCU_6_ObjN6Dst = CanConfiguration::Instance().SignalParsers()["IDCU_6_ObjN6Dst"];
        IDCU_6_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_6_reserved_2"];
        IDCU_6_ObjN6_Type = CanConfiguration::Instance().SignalParsers()["IDCU_6_ObjN6_Type"];
        IDCU_6_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_6_reserved_3"];
        IDCU_6_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_6_MsgCntr"];
        IDCU_6_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_6_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_6_reserved_1.Parser(payload);
        IDCU_6_HozlPosnRi.Parser(payload);
        IDCU_6_HozlPosnLe.Parser(payload);
        IDCU_6_ObjN6Dst.Parser(payload);
        IDCU_6_reserved_2.Parser(payload);
        IDCU_6_ObjN6_Type.Parser(payload);
        IDCU_6_reserved_3.Parser(payload);
        IDCU_6_MsgCntr.Parser(payload);
        IDCU_6_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_6_MSG(IDCU_FCM_6_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_6_reserved_1.factor;
        offset = IDCU_6_reserved_1.offset;
        msg.IDCU_6_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_reserved_1)>::type*>(&IDCU_6_reserved_1.signal);
        msg.IDCU_6_reserved_1 = msg.IDCU_6_reserved_1 * factor + offset;
        factor = IDCU_6_HozlPosnRi.factor;
        offset = IDCU_6_HozlPosnRi.offset;
        msg.IDCU_6_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_HozlPosnRi)>::type*>(&IDCU_6_HozlPosnRi.signal);
        msg.IDCU_6_HozlPosnRi = msg.IDCU_6_HozlPosnRi * factor + offset;
        factor = IDCU_6_HozlPosnLe.factor;
        offset = IDCU_6_HozlPosnLe.offset;
        msg.IDCU_6_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_HozlPosnLe)>::type*>(&IDCU_6_HozlPosnLe.signal);
        msg.IDCU_6_HozlPosnLe = msg.IDCU_6_HozlPosnLe * factor + offset;
        factor = IDCU_6_ObjN6Dst.factor;
        offset = IDCU_6_ObjN6Dst.offset;
        msg.IDCU_6_ObjN6Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_ObjN6Dst)>::type*>(&IDCU_6_ObjN6Dst.signal);
        msg.IDCU_6_ObjN6Dst = msg.IDCU_6_ObjN6Dst * factor + offset;
        factor = IDCU_6_reserved_2.factor;
        offset = IDCU_6_reserved_2.offset;
        msg.IDCU_6_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_reserved_2)>::type*>(&IDCU_6_reserved_2.signal);
        msg.IDCU_6_reserved_2 = msg.IDCU_6_reserved_2 * factor + offset;
        factor = IDCU_6_ObjN6_Type.factor;
        offset = IDCU_6_ObjN6_Type.offset;
        msg.IDCU_6_ObjN6_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_ObjN6_Type)>::type*>(&IDCU_6_ObjN6_Type.signal);
        msg.IDCU_6_ObjN6_Type = msg.IDCU_6_ObjN6_Type * factor + offset;
        factor = IDCU_6_reserved_3.factor;
        offset = IDCU_6_reserved_3.offset;
        msg.IDCU_6_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_reserved_3)>::type*>(&IDCU_6_reserved_3.signal);
        msg.IDCU_6_reserved_3 = msg.IDCU_6_reserved_3 * factor + offset;
        factor = IDCU_6_MsgCntr.factor;
        offset = IDCU_6_MsgCntr.offset;
        msg.IDCU_6_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_MsgCntr)>::type*>(&IDCU_6_MsgCntr.signal);
        msg.IDCU_6_MsgCntr = msg.IDCU_6_MsgCntr * factor + offset;
        factor = IDCU_6_CRC.factor;
        offset = IDCU_6_CRC.offset;
        msg.IDCU_6_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_6_CRC)>::type*>(&IDCU_6_CRC.signal);
        msg.IDCU_6_CRC = msg.IDCU_6_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_6_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_6_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_6_MSGMsg>();
        Struct2Proto_IDCU_FCM_6_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_6") != nullptr) {
            DFHLOG_I("idcu_fcm_6");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_6")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_6");
            return false;
         }
    }
};

struct IDCU_FCM_7_Parser {
    SignalParser IDCU_7_reserved_1;

    SignalParser IDCU_7_HozlPosnRi;

    SignalParser IDCU_7_HozlPosnLe;

    SignalParser IDCU_7_ObjN7Dst;

    SignalParser IDCU_7_reserved_2;

    SignalParser IDCU_7_ObjN7_Type;

    SignalParser IDCU_7_reserved_3;

    SignalParser IDCU_7_MsgCntr;

    SignalParser IDCU_7_CRC;

    IDCU_FCM_7_Parser() {
        IDCU_7_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_7_reserved_1"];
        IDCU_7_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_7_HozlPosnRi"];
        IDCU_7_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_7_HozlPosnLe"];
        IDCU_7_ObjN7Dst = CanConfiguration::Instance().SignalParsers()["IDCU_7_ObjN7Dst"];
        IDCU_7_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_7_reserved_2"];
        IDCU_7_ObjN7_Type = CanConfiguration::Instance().SignalParsers()["IDCU_7_ObjN7_Type"];
        IDCU_7_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_7_reserved_3"];
        IDCU_7_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_7_MsgCntr"];
        IDCU_7_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_7_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_7_reserved_1.Parser(payload);
        IDCU_7_HozlPosnRi.Parser(payload);
        IDCU_7_HozlPosnLe.Parser(payload);
        IDCU_7_ObjN7Dst.Parser(payload);
        IDCU_7_reserved_2.Parser(payload);
        IDCU_7_ObjN7_Type.Parser(payload);
        IDCU_7_reserved_3.Parser(payload);
        IDCU_7_MsgCntr.Parser(payload);
        IDCU_7_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_7_MSG(IDCU_FCM_7_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_7_reserved_1.factor;
        offset = IDCU_7_reserved_1.offset;
        msg.IDCU_7_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_reserved_1)>::type*>(&IDCU_7_reserved_1.signal);
        msg.IDCU_7_reserved_1 = msg.IDCU_7_reserved_1 * factor + offset;
        factor = IDCU_7_HozlPosnRi.factor;
        offset = IDCU_7_HozlPosnRi.offset;
        msg.IDCU_7_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_HozlPosnRi)>::type*>(&IDCU_7_HozlPosnRi.signal);
        msg.IDCU_7_HozlPosnRi = msg.IDCU_7_HozlPosnRi * factor + offset;
        factor = IDCU_7_HozlPosnLe.factor;
        offset = IDCU_7_HozlPosnLe.offset;
        msg.IDCU_7_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_HozlPosnLe)>::type*>(&IDCU_7_HozlPosnLe.signal);
        msg.IDCU_7_HozlPosnLe = msg.IDCU_7_HozlPosnLe * factor + offset;
        factor = IDCU_7_ObjN7Dst.factor;
        offset = IDCU_7_ObjN7Dst.offset;
        msg.IDCU_7_ObjN7Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_ObjN7Dst)>::type*>(&IDCU_7_ObjN7Dst.signal);
        msg.IDCU_7_ObjN7Dst = msg.IDCU_7_ObjN7Dst * factor + offset;
        factor = IDCU_7_reserved_2.factor;
        offset = IDCU_7_reserved_2.offset;
        msg.IDCU_7_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_reserved_2)>::type*>(&IDCU_7_reserved_2.signal);
        msg.IDCU_7_reserved_2 = msg.IDCU_7_reserved_2 * factor + offset;
        factor = IDCU_7_ObjN7_Type.factor;
        offset = IDCU_7_ObjN7_Type.offset;
        msg.IDCU_7_ObjN7_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_ObjN7_Type)>::type*>(&IDCU_7_ObjN7_Type.signal);
        msg.IDCU_7_ObjN7_Type = msg.IDCU_7_ObjN7_Type * factor + offset;
        factor = IDCU_7_reserved_3.factor;
        offset = IDCU_7_reserved_3.offset;
        msg.IDCU_7_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_reserved_3)>::type*>(&IDCU_7_reserved_3.signal);
        msg.IDCU_7_reserved_3 = msg.IDCU_7_reserved_3 * factor + offset;
        factor = IDCU_7_MsgCntr.factor;
        offset = IDCU_7_MsgCntr.offset;
        msg.IDCU_7_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_MsgCntr)>::type*>(&IDCU_7_MsgCntr.signal);
        msg.IDCU_7_MsgCntr = msg.IDCU_7_MsgCntr * factor + offset;
        factor = IDCU_7_CRC.factor;
        offset = IDCU_7_CRC.offset;
        msg.IDCU_7_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_7_CRC)>::type*>(&IDCU_7_CRC.signal);
        msg.IDCU_7_CRC = msg.IDCU_7_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_7_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_7_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_7_MSGMsg>();
        Struct2Proto_IDCU_FCM_7_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_7") != nullptr) {
            DFHLOG_I("idcu_fcm_7");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_7")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_7");
            return false;
         }
    }
};

struct IDCU_FCM_8_Parser {
    SignalParser IDCU_8_reserved_1;

    SignalParser IDCU_8_HozlPosnRi;

    SignalParser IDCU_8_HozlPosnLe;

    SignalParser IDCU_8_ObjN6Dst;

    SignalParser IDCU_8_reserved_2;

    SignalParser IDCU_8_ObjN8_Type;

    SignalParser IDCU_8_reserved_3;

    SignalParser IDCU_8_MsgCntr;

    SignalParser IDCU_8_CRC;

    IDCU_FCM_8_Parser() {
        IDCU_8_reserved_1 = CanConfiguration::Instance().SignalParsers()["IDCU_8_reserved_1"];
        IDCU_8_HozlPosnRi = CanConfiguration::Instance().SignalParsers()["IDCU_8_HozlPosnRi"];
        IDCU_8_HozlPosnLe = CanConfiguration::Instance().SignalParsers()["IDCU_8_HozlPosnLe"];
        IDCU_8_ObjN6Dst = CanConfiguration::Instance().SignalParsers()["IDCU_8_ObjN6Dst"];
        IDCU_8_reserved_2 = CanConfiguration::Instance().SignalParsers()["IDCU_8_reserved_2"];
        IDCU_8_ObjN8_Type = CanConfiguration::Instance().SignalParsers()["IDCU_8_ObjN8_Type"];
        IDCU_8_reserved_3 = CanConfiguration::Instance().SignalParsers()["IDCU_8_reserved_3"];
        IDCU_8_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_8_MsgCntr"];
        IDCU_8_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_8_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_8_reserved_1.Parser(payload);
        IDCU_8_HozlPosnRi.Parser(payload);
        IDCU_8_HozlPosnLe.Parser(payload);
        IDCU_8_ObjN6Dst.Parser(payload);
        IDCU_8_reserved_2.Parser(payload);
        IDCU_8_ObjN8_Type.Parser(payload);
        IDCU_8_reserved_3.Parser(payload);
        IDCU_8_MsgCntr.Parser(payload);
        IDCU_8_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_FCM_8_MSG(IDCU_FCM_8_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_8_reserved_1.factor;
        offset = IDCU_8_reserved_1.offset;
        msg.IDCU_8_reserved_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_reserved_1)>::type*>(&IDCU_8_reserved_1.signal);
        msg.IDCU_8_reserved_1 = msg.IDCU_8_reserved_1 * factor + offset;
        factor = IDCU_8_HozlPosnRi.factor;
        offset = IDCU_8_HozlPosnRi.offset;
        msg.IDCU_8_HozlPosnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_HozlPosnRi)>::type*>(&IDCU_8_HozlPosnRi.signal);
        msg.IDCU_8_HozlPosnRi = msg.IDCU_8_HozlPosnRi * factor + offset;
        factor = IDCU_8_HozlPosnLe.factor;
        offset = IDCU_8_HozlPosnLe.offset;
        msg.IDCU_8_HozlPosnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_HozlPosnLe)>::type*>(&IDCU_8_HozlPosnLe.signal);
        msg.IDCU_8_HozlPosnLe = msg.IDCU_8_HozlPosnLe * factor + offset;
        factor = IDCU_8_ObjN6Dst.factor;
        offset = IDCU_8_ObjN6Dst.offset;
        msg.IDCU_8_ObjN6Dst = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_ObjN6Dst)>::type*>(&IDCU_8_ObjN6Dst.signal);
        msg.IDCU_8_ObjN6Dst = msg.IDCU_8_ObjN6Dst * factor + offset;
        factor = IDCU_8_reserved_2.factor;
        offset = IDCU_8_reserved_2.offset;
        msg.IDCU_8_reserved_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_reserved_2)>::type*>(&IDCU_8_reserved_2.signal);
        msg.IDCU_8_reserved_2 = msg.IDCU_8_reserved_2 * factor + offset;
        factor = IDCU_8_ObjN8_Type.factor;
        offset = IDCU_8_ObjN8_Type.offset;
        msg.IDCU_8_ObjN8_Type = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_ObjN8_Type)>::type*>(&IDCU_8_ObjN8_Type.signal);
        msg.IDCU_8_ObjN8_Type = msg.IDCU_8_ObjN8_Type * factor + offset;
        factor = IDCU_8_reserved_3.factor;
        offset = IDCU_8_reserved_3.offset;
        msg.IDCU_8_reserved_3 = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_reserved_3)>::type*>(&IDCU_8_reserved_3.signal);
        msg.IDCU_8_reserved_3 = msg.IDCU_8_reserved_3 * factor + offset;
        factor = IDCU_8_MsgCntr.factor;
        offset = IDCU_8_MsgCntr.offset;
        msg.IDCU_8_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_MsgCntr)>::type*>(&IDCU_8_MsgCntr.signal);
        msg.IDCU_8_MsgCntr = msg.IDCU_8_MsgCntr * factor + offset;
        factor = IDCU_8_CRC.factor;
        offset = IDCU_8_CRC.offset;
        msg.IDCU_8_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_8_CRC)>::type*>(&IDCU_8_CRC.signal);
        msg.IDCU_8_CRC = msg.IDCU_8_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_FCM_8_MSG can_struct;
        CanParser2CanStruct_IDCU_FCM_8_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_FCM_8_MSGMsg>();
        Struct2Proto_IDCU_FCM_8_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_fcm_8") != nullptr) {
            DFHLOG_I("idcu_fcm_8");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_fcm_8")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_fcm_8");
            return false;
         }
    }
};

struct IDCU_9_Parser {
    SignalParser IDCU_9_AVPRemCtrlSts;

    SignalParser IDCU_9_AVPReqLeRiLi;

    SignalParser IDCU_9_AVPReqHdLoLi;

    SignalParser IDCU_9_AVPReqOutdReviMirr;

    SignalParser IDCU_9_AVPReqfourdoorlock;

    SignalParser IDCU_9_AVPFailrSt;

    SignalParser IDCU_9_AVPReqWinTurnDwn;

    SignalParser IDCU_9_AVPReqClsSunRoof;

    SignalParser IDCU_9_AVPReqHorn;

    SignalParser IDCU_9_BackOut;

    SignalParser IDCU_9_BackLeftCross;

    SignalParser IDCU_9_BackRightCross;

    SignalParser IDCU_9_AVPMatcSts;

    SignalParser IDCU_9_AVPReqPEPS;

    SignalParser IDCU_9_AVPFunReq;

    SignalParser IDCU_9_AVPModReqAutoPrkg;

    SignalParser IDCU_9_AVPModReqAutoParkOut;

    SignalParser IDCU_9_AVPModReqRmtPrkg;

    SignalParser IDCU_9_AVPModReqRmtParkOut;

    SignalParser IDCU_9_AVPModReqBackForth;

    SignalParser Read_IDCU_9_AVPModReqCruisePrkg;

    SignalParser IDCU_9_FrontOut;

    SignalParser IDCU_9_AVPModReqMmryPrkg;

    SignalParser IDCU_9_AVPModReqMmryParkOut;

    SignalParser IDCU_9_AVPPrkgSpd;

    SignalParser IDCU_9_AVPPrkgslot;

    SignalParser IDCU_9_FrontLeftCross;

    SignalParser IDCU_9_FrontLeftParallel;

    SignalParser IDCU_9_FrontRightCross;

    SignalParser IDCU_9_FrontRightParallel;

    SignalParser IDCU_9_ParkOutDirectionSt;

    SignalParser IDCU_9_AVPRecaFailrSt;

    SignalParser IDCU_9_MsgCntr;

    SignalParser IDCU_9_CRC;

    IDCU_9_Parser() {
        IDCU_9_AVPRemCtrlSts = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPRemCtrlSts"];
        IDCU_9_AVPReqLeRiLi = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqLeRiLi"];
        IDCU_9_AVPReqHdLoLi = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqHdLoLi"];
        IDCU_9_AVPReqOutdReviMirr = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqOutdReviMirr"];
        IDCU_9_AVPReqfourdoorlock = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqfourdoorlock"];
        IDCU_9_AVPFailrSt = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPFailrSt"];
        IDCU_9_AVPReqWinTurnDwn = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqWinTurnDwn"];
        IDCU_9_AVPReqClsSunRoof = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqClsSunRoof"];
        IDCU_9_AVPReqHorn = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqHorn"];
        IDCU_9_BackOut = CanConfiguration::Instance().SignalParsers()["IDCU_9_BackOut"];
        IDCU_9_BackLeftCross = CanConfiguration::Instance().SignalParsers()["IDCU_9_BackLeftCross"];
        IDCU_9_BackRightCross = CanConfiguration::Instance().SignalParsers()["IDCU_9_BackRightCross"];
        IDCU_9_AVPMatcSts = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPMatcSts"];
        IDCU_9_AVPReqPEPS = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPReqPEPS"];
        IDCU_9_AVPFunReq = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPFunReq"];
        IDCU_9_AVPModReqAutoPrkg = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqAutoPrkg"];
        IDCU_9_AVPModReqAutoParkOut = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqAutoParkOut"];
        IDCU_9_AVPModReqRmtPrkg = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqRmtPrkg"];
        IDCU_9_AVPModReqRmtParkOut = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqRmtParkOut"];
        IDCU_9_AVPModReqBackForth = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqBackForth"];
        Read_IDCU_9_AVPModReqCruisePrkg = CanConfiguration::Instance().SignalParsers()["Read_IDCU_9_AVPModReqCruisePrkg"];
        IDCU_9_FrontOut = CanConfiguration::Instance().SignalParsers()["IDCU_9_FrontOut"];
        IDCU_9_AVPModReqMmryPrkg = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqMmryPrkg"];
        IDCU_9_AVPModReqMmryParkOut = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPModReqMmryParkOut"];
        IDCU_9_AVPPrkgSpd = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPPrkgSpd"];
        IDCU_9_AVPPrkgslot = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPPrkgslot"];
        IDCU_9_FrontLeftCross = CanConfiguration::Instance().SignalParsers()["IDCU_9_FrontLeftCross"];
        IDCU_9_FrontLeftParallel = CanConfiguration::Instance().SignalParsers()["IDCU_9_FrontLeftParallel"];
        IDCU_9_FrontRightCross = CanConfiguration::Instance().SignalParsers()["IDCU_9_FrontRightCross"];
        IDCU_9_FrontRightParallel = CanConfiguration::Instance().SignalParsers()["IDCU_9_FrontRightParallel"];
        IDCU_9_ParkOutDirectionSt = CanConfiguration::Instance().SignalParsers()["IDCU_9_ParkOutDirectionSt"];
        IDCU_9_AVPRecaFailrSt = CanConfiguration::Instance().SignalParsers()["IDCU_9_AVPRecaFailrSt"];
        IDCU_9_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_9_MsgCntr"];
        IDCU_9_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_9_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_9_AVPRemCtrlSts.Parser(payload);
        IDCU_9_AVPReqLeRiLi.Parser(payload);
        IDCU_9_AVPReqHdLoLi.Parser(payload);
        IDCU_9_AVPReqOutdReviMirr.Parser(payload);
        IDCU_9_AVPReqfourdoorlock.Parser(payload);
        IDCU_9_AVPFailrSt.Parser(payload);
        IDCU_9_AVPReqWinTurnDwn.Parser(payload);
        IDCU_9_AVPReqClsSunRoof.Parser(payload);
        IDCU_9_AVPReqHorn.Parser(payload);
        IDCU_9_BackOut.Parser(payload);
        IDCU_9_BackLeftCross.Parser(payload);
        IDCU_9_BackRightCross.Parser(payload);
        IDCU_9_AVPMatcSts.Parser(payload);
        IDCU_9_AVPReqPEPS.Parser(payload);
        IDCU_9_AVPFunReq.Parser(payload);
        IDCU_9_AVPModReqAutoPrkg.Parser(payload);
        IDCU_9_AVPModReqAutoParkOut.Parser(payload);
        IDCU_9_AVPModReqRmtPrkg.Parser(payload);
        IDCU_9_AVPModReqRmtParkOut.Parser(payload);
        IDCU_9_AVPModReqBackForth.Parser(payload);
        Read_IDCU_9_AVPModReqCruisePrkg.Parser(payload);
        IDCU_9_FrontOut.Parser(payload);
        IDCU_9_AVPModReqMmryPrkg.Parser(payload);
        IDCU_9_AVPModReqMmryParkOut.Parser(payload);
        IDCU_9_AVPPrkgSpd.Parser(payload);
        IDCU_9_AVPPrkgslot.Parser(payload);
        IDCU_9_FrontLeftCross.Parser(payload);
        IDCU_9_FrontLeftParallel.Parser(payload);
        IDCU_9_FrontRightCross.Parser(payload);
        IDCU_9_FrontRightParallel.Parser(payload);
        IDCU_9_ParkOutDirectionSt.Parser(payload);
        IDCU_9_AVPRecaFailrSt.Parser(payload);
        IDCU_9_MsgCntr.Parser(payload);
        IDCU_9_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_9_MSG(IDCU_9_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_9_AVPRemCtrlSts.factor;
        offset = IDCU_9_AVPRemCtrlSts.offset;
        msg.IDCU_9_AVPRemCtrlSts = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPRemCtrlSts)>::type*>(&IDCU_9_AVPRemCtrlSts.signal);
        msg.IDCU_9_AVPRemCtrlSts = msg.IDCU_9_AVPRemCtrlSts * factor + offset;
        factor = IDCU_9_AVPReqLeRiLi.factor;
        offset = IDCU_9_AVPReqLeRiLi.offset;
        msg.IDCU_9_AVPReqLeRiLi = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqLeRiLi)>::type*>(&IDCU_9_AVPReqLeRiLi.signal);
        msg.IDCU_9_AVPReqLeRiLi = msg.IDCU_9_AVPReqLeRiLi * factor + offset;
        factor = IDCU_9_AVPReqHdLoLi.factor;
        offset = IDCU_9_AVPReqHdLoLi.offset;
        msg.IDCU_9_AVPReqHdLoLi = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqHdLoLi)>::type*>(&IDCU_9_AVPReqHdLoLi.signal);
        msg.IDCU_9_AVPReqHdLoLi = msg.IDCU_9_AVPReqHdLoLi * factor + offset;
        factor = IDCU_9_AVPReqOutdReviMirr.factor;
        offset = IDCU_9_AVPReqOutdReviMirr.offset;
        msg.IDCU_9_AVPReqOutdReviMirr = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqOutdReviMirr)>::type*>(&IDCU_9_AVPReqOutdReviMirr.signal);
        msg.IDCU_9_AVPReqOutdReviMirr = msg.IDCU_9_AVPReqOutdReviMirr * factor + offset;
        factor = IDCU_9_AVPReqfourdoorlock.factor;
        offset = IDCU_9_AVPReqfourdoorlock.offset;
        msg.IDCU_9_AVPReqfourdoorlock = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqfourdoorlock)>::type*>(&IDCU_9_AVPReqfourdoorlock.signal);
        msg.IDCU_9_AVPReqfourdoorlock = msg.IDCU_9_AVPReqfourdoorlock * factor + offset;
        factor = IDCU_9_AVPFailrSt.factor;
        offset = IDCU_9_AVPFailrSt.offset;
        msg.IDCU_9_AVPFailrSt = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPFailrSt)>::type*>(&IDCU_9_AVPFailrSt.signal);
        msg.IDCU_9_AVPFailrSt = msg.IDCU_9_AVPFailrSt * factor + offset;
        factor = IDCU_9_AVPReqWinTurnDwn.factor;
        offset = IDCU_9_AVPReqWinTurnDwn.offset;
        msg.IDCU_9_AVPReqWinTurnDwn = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqWinTurnDwn)>::type*>(&IDCU_9_AVPReqWinTurnDwn.signal);
        msg.IDCU_9_AVPReqWinTurnDwn = msg.IDCU_9_AVPReqWinTurnDwn * factor + offset;
        factor = IDCU_9_AVPReqClsSunRoof.factor;
        offset = IDCU_9_AVPReqClsSunRoof.offset;
        msg.IDCU_9_AVPReqClsSunRoof = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqClsSunRoof)>::type*>(&IDCU_9_AVPReqClsSunRoof.signal);
        msg.IDCU_9_AVPReqClsSunRoof = msg.IDCU_9_AVPReqClsSunRoof * factor + offset;
        factor = IDCU_9_AVPReqHorn.factor;
        offset = IDCU_9_AVPReqHorn.offset;
        msg.IDCU_9_AVPReqHorn = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqHorn)>::type*>(&IDCU_9_AVPReqHorn.signal);
        msg.IDCU_9_AVPReqHorn = msg.IDCU_9_AVPReqHorn * factor + offset;
        factor = IDCU_9_BackOut.factor;
        offset = IDCU_9_BackOut.offset;
        msg.IDCU_9_BackOut = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_BackOut)>::type*>(&IDCU_9_BackOut.signal);
        msg.IDCU_9_BackOut = msg.IDCU_9_BackOut * factor + offset;
        factor = IDCU_9_BackLeftCross.factor;
        offset = IDCU_9_BackLeftCross.offset;
        msg.IDCU_9_BackLeftCross = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_BackLeftCross)>::type*>(&IDCU_9_BackLeftCross.signal);
        msg.IDCU_9_BackLeftCross = msg.IDCU_9_BackLeftCross * factor + offset;
        factor = IDCU_9_BackRightCross.factor;
        offset = IDCU_9_BackRightCross.offset;
        msg.IDCU_9_BackRightCross = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_BackRightCross)>::type*>(&IDCU_9_BackRightCross.signal);
        msg.IDCU_9_BackRightCross = msg.IDCU_9_BackRightCross * factor + offset;
        factor = IDCU_9_AVPMatcSts.factor;
        offset = IDCU_9_AVPMatcSts.offset;
        msg.IDCU_9_AVPMatcSts = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPMatcSts)>::type*>(&IDCU_9_AVPMatcSts.signal);
        msg.IDCU_9_AVPMatcSts = msg.IDCU_9_AVPMatcSts * factor + offset;
        factor = IDCU_9_AVPReqPEPS.factor;
        offset = IDCU_9_AVPReqPEPS.offset;
        msg.IDCU_9_AVPReqPEPS = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPReqPEPS)>::type*>(&IDCU_9_AVPReqPEPS.signal);
        msg.IDCU_9_AVPReqPEPS = msg.IDCU_9_AVPReqPEPS * factor + offset;
        factor = IDCU_9_AVPFunReq.factor;
        offset = IDCU_9_AVPFunReq.offset;
        msg.IDCU_9_AVPFunReq = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPFunReq)>::type*>(&IDCU_9_AVPFunReq.signal);
        msg.IDCU_9_AVPFunReq = msg.IDCU_9_AVPFunReq * factor + offset;
        factor = IDCU_9_AVPModReqAutoPrkg.factor;
        offset = IDCU_9_AVPModReqAutoPrkg.offset;
        msg.IDCU_9_AVPModReqAutoPrkg = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqAutoPrkg)>::type*>(&IDCU_9_AVPModReqAutoPrkg.signal);
        msg.IDCU_9_AVPModReqAutoPrkg = msg.IDCU_9_AVPModReqAutoPrkg * factor + offset;
        factor = IDCU_9_AVPModReqAutoParkOut.factor;
        offset = IDCU_9_AVPModReqAutoParkOut.offset;
        msg.IDCU_9_AVPModReqAutoParkOut = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqAutoParkOut)>::type*>(&IDCU_9_AVPModReqAutoParkOut.signal);
        msg.IDCU_9_AVPModReqAutoParkOut = msg.IDCU_9_AVPModReqAutoParkOut * factor + offset;
        factor = IDCU_9_AVPModReqRmtPrkg.factor;
        offset = IDCU_9_AVPModReqRmtPrkg.offset;
        msg.IDCU_9_AVPModReqRmtPrkg = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqRmtPrkg)>::type*>(&IDCU_9_AVPModReqRmtPrkg.signal);
        msg.IDCU_9_AVPModReqRmtPrkg = msg.IDCU_9_AVPModReqRmtPrkg * factor + offset;
        factor = IDCU_9_AVPModReqRmtParkOut.factor;
        offset = IDCU_9_AVPModReqRmtParkOut.offset;
        msg.IDCU_9_AVPModReqRmtParkOut = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqRmtParkOut)>::type*>(&IDCU_9_AVPModReqRmtParkOut.signal);
        msg.IDCU_9_AVPModReqRmtParkOut = msg.IDCU_9_AVPModReqRmtParkOut * factor + offset;
        factor = IDCU_9_AVPModReqBackForth.factor;
        offset = IDCU_9_AVPModReqBackForth.offset;
        msg.IDCU_9_AVPModReqBackForth = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqBackForth)>::type*>(&IDCU_9_AVPModReqBackForth.signal);
        msg.IDCU_9_AVPModReqBackForth = msg.IDCU_9_AVPModReqBackForth * factor + offset;
        factor = Read_IDCU_9_AVPModReqCruisePrkg.factor;
        offset = Read_IDCU_9_AVPModReqCruisePrkg.offset;
        msg.Read_IDCU_9_AVPModReqCruisePrkg = *reinterpret_cast<std::decay<decltype(msg.Read_IDCU_9_AVPModReqCruisePrkg)>::type*>(&Read_IDCU_9_AVPModReqCruisePrkg.signal);
        msg.Read_IDCU_9_AVPModReqCruisePrkg = msg.Read_IDCU_9_AVPModReqCruisePrkg * factor + offset;
        factor = IDCU_9_FrontOut.factor;
        offset = IDCU_9_FrontOut.offset;
        msg.IDCU_9_FrontOut = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_FrontOut)>::type*>(&IDCU_9_FrontOut.signal);
        msg.IDCU_9_FrontOut = msg.IDCU_9_FrontOut * factor + offset;
        factor = IDCU_9_AVPModReqMmryPrkg.factor;
        offset = IDCU_9_AVPModReqMmryPrkg.offset;
        msg.IDCU_9_AVPModReqMmryPrkg = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqMmryPrkg)>::type*>(&IDCU_9_AVPModReqMmryPrkg.signal);
        msg.IDCU_9_AVPModReqMmryPrkg = msg.IDCU_9_AVPModReqMmryPrkg * factor + offset;
        factor = IDCU_9_AVPModReqMmryParkOut.factor;
        offset = IDCU_9_AVPModReqMmryParkOut.offset;
        msg.IDCU_9_AVPModReqMmryParkOut = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPModReqMmryParkOut)>::type*>(&IDCU_9_AVPModReqMmryParkOut.signal);
        msg.IDCU_9_AVPModReqMmryParkOut = msg.IDCU_9_AVPModReqMmryParkOut * factor + offset;
        factor = IDCU_9_AVPPrkgSpd.factor;
        offset = IDCU_9_AVPPrkgSpd.offset;
        msg.IDCU_9_AVPPrkgSpd = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPPrkgSpd)>::type*>(&IDCU_9_AVPPrkgSpd.signal);
        msg.IDCU_9_AVPPrkgSpd = msg.IDCU_9_AVPPrkgSpd * factor + offset;
        factor = IDCU_9_AVPPrkgslot.factor;
        offset = IDCU_9_AVPPrkgslot.offset;
        msg.IDCU_9_AVPPrkgslot = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPPrkgslot)>::type*>(&IDCU_9_AVPPrkgslot.signal);
        msg.IDCU_9_AVPPrkgslot = msg.IDCU_9_AVPPrkgslot * factor + offset;
        factor = IDCU_9_FrontLeftCross.factor;
        offset = IDCU_9_FrontLeftCross.offset;
        msg.IDCU_9_FrontLeftCross = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_FrontLeftCross)>::type*>(&IDCU_9_FrontLeftCross.signal);
        msg.IDCU_9_FrontLeftCross = msg.IDCU_9_FrontLeftCross * factor + offset;
        factor = IDCU_9_FrontLeftParallel.factor;
        offset = IDCU_9_FrontLeftParallel.offset;
        msg.IDCU_9_FrontLeftParallel = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_FrontLeftParallel)>::type*>(&IDCU_9_FrontLeftParallel.signal);
        msg.IDCU_9_FrontLeftParallel = msg.IDCU_9_FrontLeftParallel * factor + offset;
        factor = IDCU_9_FrontRightCross.factor;
        offset = IDCU_9_FrontRightCross.offset;
        msg.IDCU_9_FrontRightCross = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_FrontRightCross)>::type*>(&IDCU_9_FrontRightCross.signal);
        msg.IDCU_9_FrontRightCross = msg.IDCU_9_FrontRightCross * factor + offset;
        factor = IDCU_9_FrontRightParallel.factor;
        offset = IDCU_9_FrontRightParallel.offset;
        msg.IDCU_9_FrontRightParallel = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_FrontRightParallel)>::type*>(&IDCU_9_FrontRightParallel.signal);
        msg.IDCU_9_FrontRightParallel = msg.IDCU_9_FrontRightParallel * factor + offset;
        factor = IDCU_9_ParkOutDirectionSt.factor;
        offset = IDCU_9_ParkOutDirectionSt.offset;
        msg.IDCU_9_ParkOutDirectionSt = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_ParkOutDirectionSt)>::type*>(&IDCU_9_ParkOutDirectionSt.signal);
        msg.IDCU_9_ParkOutDirectionSt = msg.IDCU_9_ParkOutDirectionSt * factor + offset;
        factor = IDCU_9_AVPRecaFailrSt.factor;
        offset = IDCU_9_AVPRecaFailrSt.offset;
        msg.IDCU_9_AVPRecaFailrSt = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_AVPRecaFailrSt)>::type*>(&IDCU_9_AVPRecaFailrSt.signal);
        msg.IDCU_9_AVPRecaFailrSt = msg.IDCU_9_AVPRecaFailrSt * factor + offset;
        factor = IDCU_9_MsgCntr.factor;
        offset = IDCU_9_MsgCntr.offset;
        msg.IDCU_9_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_MsgCntr)>::type*>(&IDCU_9_MsgCntr.signal);
        msg.IDCU_9_MsgCntr = msg.IDCU_9_MsgCntr * factor + offset;
        factor = IDCU_9_CRC.factor;
        offset = IDCU_9_CRC.offset;
        msg.IDCU_9_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_9_CRC)>::type*>(&IDCU_9_CRC.signal);
        msg.IDCU_9_CRC = msg.IDCU_9_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_9_MSG can_struct;
        CanParser2CanStruct_IDCU_9_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_9_MSGMsg>();
        Struct2Proto_IDCU_9_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_9") != nullptr) {
            DFHLOG_I("idcu_9");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_9")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_9");
            return false;
         }
    }
};

struct IDCU_10_Parser {
    SignalParser IDCU_10AVPTarA;

    SignalParser IDCU_10AVPACmdEnable;

    SignalParser IDCU_10AVPModForIPB;

    SignalParser IDCU_10AVPStandstillReq;

    SignalParser IDCU_10AVPVehStrtReq;

    SignalParser IDCU_10AVPBrkFirst;

    SignalParser IDCU_10AVPTarASlopUpprLim;

    SignalParser IDCU_10AVPTarASlopLowrLim;

    SignalParser IDCU_10AVPTarALowrLim;

    SignalParser IDCU_10AVPTarAUpprLim;

    SignalParser IDCU_10_Resd1;

    SignalParser IDCU_10_MsgCntr;

    SignalParser IDCU_10_CRC;

    IDCU_10_Parser() {
        IDCU_10AVPTarA = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPTarA"];
        IDCU_10AVPACmdEnable = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPACmdEnable"];
        IDCU_10AVPModForIPB = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPModForIPB"];
        IDCU_10AVPStandstillReq = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPStandstillReq"];
        IDCU_10AVPVehStrtReq = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPVehStrtReq"];
        IDCU_10AVPBrkFirst = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPBrkFirst"];
        IDCU_10AVPTarASlopUpprLim = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPTarASlopUpprLim"];
        IDCU_10AVPTarASlopLowrLim = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPTarASlopLowrLim"];
        IDCU_10AVPTarALowrLim = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPTarALowrLim"];
        IDCU_10AVPTarAUpprLim = CanConfiguration::Instance().SignalParsers()["IDCU_10AVPTarAUpprLim"];
        IDCU_10_Resd1 = CanConfiguration::Instance().SignalParsers()["IDCU_10_Resd1"];
        IDCU_10_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_10_MsgCntr"];
        IDCU_10_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_10_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_10AVPTarA.Parser(payload);
        IDCU_10AVPACmdEnable.Parser(payload);
        IDCU_10AVPModForIPB.Parser(payload);
        IDCU_10AVPStandstillReq.Parser(payload);
        IDCU_10AVPVehStrtReq.Parser(payload);
        IDCU_10AVPBrkFirst.Parser(payload);
        IDCU_10AVPTarASlopUpprLim.Parser(payload);
        IDCU_10AVPTarASlopLowrLim.Parser(payload);
        IDCU_10AVPTarALowrLim.Parser(payload);
        IDCU_10AVPTarAUpprLim.Parser(payload);
        IDCU_10_Resd1.Parser(payload);
        IDCU_10_MsgCntr.Parser(payload);
        IDCU_10_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_10_MSG(IDCU_10_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_10AVPTarA.factor;
        offset = IDCU_10AVPTarA.offset;
        msg.IDCU_10AVPTarA = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPTarA)>::type*>(&IDCU_10AVPTarA.signal);
        msg.IDCU_10AVPTarA = msg.IDCU_10AVPTarA * factor + offset;
        factor = IDCU_10AVPACmdEnable.factor;
        offset = IDCU_10AVPACmdEnable.offset;
        msg.IDCU_10AVPACmdEnable = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPACmdEnable)>::type*>(&IDCU_10AVPACmdEnable.signal);
        msg.IDCU_10AVPACmdEnable = msg.IDCU_10AVPACmdEnable * factor + offset;
        factor = IDCU_10AVPModForIPB.factor;
        offset = IDCU_10AVPModForIPB.offset;
        msg.IDCU_10AVPModForIPB = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPModForIPB)>::type*>(&IDCU_10AVPModForIPB.signal);
        msg.IDCU_10AVPModForIPB = msg.IDCU_10AVPModForIPB * factor + offset;
        factor = IDCU_10AVPStandstillReq.factor;
        offset = IDCU_10AVPStandstillReq.offset;
        msg.IDCU_10AVPStandstillReq = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPStandstillReq)>::type*>(&IDCU_10AVPStandstillReq.signal);
        msg.IDCU_10AVPStandstillReq = msg.IDCU_10AVPStandstillReq * factor + offset;
        factor = IDCU_10AVPVehStrtReq.factor;
        offset = IDCU_10AVPVehStrtReq.offset;
        msg.IDCU_10AVPVehStrtReq = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPVehStrtReq)>::type*>(&IDCU_10AVPVehStrtReq.signal);
        msg.IDCU_10AVPVehStrtReq = msg.IDCU_10AVPVehStrtReq * factor + offset;
        factor = IDCU_10AVPBrkFirst.factor;
        offset = IDCU_10AVPBrkFirst.offset;
        msg.IDCU_10AVPBrkFirst = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPBrkFirst)>::type*>(&IDCU_10AVPBrkFirst.signal);
        msg.IDCU_10AVPBrkFirst = msg.IDCU_10AVPBrkFirst * factor + offset;
        factor = IDCU_10AVPTarASlopUpprLim.factor;
        offset = IDCU_10AVPTarASlopUpprLim.offset;
        msg.IDCU_10AVPTarASlopUpprLim = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPTarASlopUpprLim)>::type*>(&IDCU_10AVPTarASlopUpprLim.signal);
        msg.IDCU_10AVPTarASlopUpprLim = msg.IDCU_10AVPTarASlopUpprLim * factor + offset;
        factor = IDCU_10AVPTarASlopLowrLim.factor;
        offset = IDCU_10AVPTarASlopLowrLim.offset;
        msg.IDCU_10AVPTarASlopLowrLim = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPTarASlopLowrLim)>::type*>(&IDCU_10AVPTarASlopLowrLim.signal);
        msg.IDCU_10AVPTarASlopLowrLim = msg.IDCU_10AVPTarASlopLowrLim * factor + offset;
        factor = IDCU_10AVPTarALowrLim.factor;
        offset = IDCU_10AVPTarALowrLim.offset;
        msg.IDCU_10AVPTarALowrLim = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPTarALowrLim)>::type*>(&IDCU_10AVPTarALowrLim.signal);
        msg.IDCU_10AVPTarALowrLim = msg.IDCU_10AVPTarALowrLim * factor + offset;
        factor = IDCU_10AVPTarAUpprLim.factor;
        offset = IDCU_10AVPTarAUpprLim.offset;
        msg.IDCU_10AVPTarAUpprLim = *reinterpret_cast<std::decay<decltype(msg.IDCU_10AVPTarAUpprLim)>::type*>(&IDCU_10AVPTarAUpprLim.signal);
        msg.IDCU_10AVPTarAUpprLim = msg.IDCU_10AVPTarAUpprLim * factor + offset;
        factor = IDCU_10_Resd1.factor;
        offset = IDCU_10_Resd1.offset;
        msg.IDCU_10_Resd1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_10_Resd1)>::type*>(&IDCU_10_Resd1.signal);
        msg.IDCU_10_Resd1 = msg.IDCU_10_Resd1 * factor + offset;
        factor = IDCU_10_MsgCntr.factor;
        offset = IDCU_10_MsgCntr.offset;
        msg.IDCU_10_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_10_MsgCntr)>::type*>(&IDCU_10_MsgCntr.signal);
        msg.IDCU_10_MsgCntr = msg.IDCU_10_MsgCntr * factor + offset;
        factor = IDCU_10_CRC.factor;
        offset = IDCU_10_CRC.offset;
        msg.IDCU_10_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_10_CRC)>::type*>(&IDCU_10_CRC.signal);
        msg.IDCU_10_CRC = msg.IDCU_10_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_10_MSG can_struct;
        CanParser2CanStruct_IDCU_10_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_10_MSGMsg>();
        Struct2Proto_IDCU_10_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_10") != nullptr) {
            DFHLOG_I("idcu_10");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_10")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_10");
            return false;
         }
    }
};

struct IDCU_11_Parser {
    SignalParser IDCU_11_CPONOFFsts;

    SignalParser IDCU_11_NOCONOFFsts;

    SignalParser IDCU_11_ALCDrvrCfmONOFFsts;

    SignalParser IDCU_11_ALCDrvStysts;

    SignalParser IDCU_11_FCTBONOFFsts;

    SignalParser IDCU_11_PPMIMod;

    SignalParser IDCU_11_DCLCONOFFsts;

    SignalParser IDCU_11_PrkgIntrptVoice;

    SignalParser IDCU_11_DrvAssiStylests;

    SignalParser IDCU_11_VoiceRem;

    SignalParser IDCU_11_HPAONOFFsts;

    SignalParser IDCU_1_Resd;

    SignalParser IDCU_11_ParkingchimeVoice;

    SignalParser IDCU_11_ParkIntSts;

    SignalParser IDCU_11_StartButtonSts;

    SignalParser IDCU_11_ResumeButtonSts;

    SignalParser IDCU_11_RPAParkingDriOperateInd;

    SignalParser IDCU_11_ParkingProgressBarInd;

    SignalParser IDCU_11_Resd_2;

    SignalParser IDCU_11_MsgCntr;

    SignalParser IDCU_11_CRC;

    IDCU_11_Parser() {
        IDCU_11_CPONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_CPONOFFsts"];
        IDCU_11_NOCONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_NOCONOFFsts"];
        IDCU_11_ALCDrvrCfmONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_ALCDrvrCfmONOFFsts"];
        IDCU_11_ALCDrvStysts = CanConfiguration::Instance().SignalParsers()["IDCU_11_ALCDrvStysts"];
        IDCU_11_FCTBONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_FCTBONOFFsts"];
        IDCU_11_PPMIMod = CanConfiguration::Instance().SignalParsers()["IDCU_11_PPMIMod"];
        IDCU_11_DCLCONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_DCLCONOFFsts"];
        IDCU_11_PrkgIntrptVoice = CanConfiguration::Instance().SignalParsers()["IDCU_11_PrkgIntrptVoice"];
        IDCU_11_DrvAssiStylests = CanConfiguration::Instance().SignalParsers()["IDCU_11_DrvAssiStylests"];
        IDCU_11_VoiceRem = CanConfiguration::Instance().SignalParsers()["IDCU_11_VoiceRem"];
        IDCU_11_HPAONOFFsts = CanConfiguration::Instance().SignalParsers()["IDCU_11_HPAONOFFsts"];
        IDCU_1_Resd = CanConfiguration::Instance().SignalParsers()["IDCU_1_Resd"];
        IDCU_11_ParkingchimeVoice = CanConfiguration::Instance().SignalParsers()["IDCU_11_ParkingchimeVoice"];
        IDCU_11_ParkIntSts = CanConfiguration::Instance().SignalParsers()["IDCU_11_ParkIntSts"];
        IDCU_11_StartButtonSts = CanConfiguration::Instance().SignalParsers()["IDCU_11_StartButtonSts"];
        IDCU_11_ResumeButtonSts = CanConfiguration::Instance().SignalParsers()["IDCU_11_ResumeButtonSts"];
        IDCU_11_RPAParkingDriOperateInd = CanConfiguration::Instance().SignalParsers()["IDCU_11_RPAParkingDriOperateInd"];
        IDCU_11_ParkingProgressBarInd = CanConfiguration::Instance().SignalParsers()["IDCU_11_ParkingProgressBarInd"];
        IDCU_11_Resd_2 = CanConfiguration::Instance().SignalParsers()["IDCU_11_Resd_2"];
        IDCU_11_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_11_MsgCntr"];
        IDCU_11_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_11_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_11_CPONOFFsts.Parser(payload);
        IDCU_11_NOCONOFFsts.Parser(payload);
        IDCU_11_ALCDrvrCfmONOFFsts.Parser(payload);
        IDCU_11_ALCDrvStysts.Parser(payload);
        IDCU_11_FCTBONOFFsts.Parser(payload);
        IDCU_11_PPMIMod.Parser(payload);
        IDCU_11_DCLCONOFFsts.Parser(payload);
        IDCU_11_PrkgIntrptVoice.Parser(payload);
        IDCU_11_DrvAssiStylests.Parser(payload);
        IDCU_11_VoiceRem.Parser(payload);
        IDCU_11_HPAONOFFsts.Parser(payload);
        IDCU_1_Resd.Parser(payload);
        IDCU_11_ParkingchimeVoice.Parser(payload);
        IDCU_11_ParkIntSts.Parser(payload);
        IDCU_11_StartButtonSts.Parser(payload);
        IDCU_11_ResumeButtonSts.Parser(payload);
        IDCU_11_RPAParkingDriOperateInd.Parser(payload);
        IDCU_11_ParkingProgressBarInd.Parser(payload);
        IDCU_11_Resd_2.Parser(payload);
        IDCU_11_MsgCntr.Parser(payload);
        IDCU_11_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_11_MSG(IDCU_11_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_11_CPONOFFsts.factor;
        offset = IDCU_11_CPONOFFsts.offset;
        msg.IDCU_11_CPONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_CPONOFFsts)>::type*>(&IDCU_11_CPONOFFsts.signal);
        msg.IDCU_11_CPONOFFsts = msg.IDCU_11_CPONOFFsts * factor + offset;
        factor = IDCU_11_NOCONOFFsts.factor;
        offset = IDCU_11_NOCONOFFsts.offset;
        msg.IDCU_11_NOCONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_NOCONOFFsts)>::type*>(&IDCU_11_NOCONOFFsts.signal);
        msg.IDCU_11_NOCONOFFsts = msg.IDCU_11_NOCONOFFsts * factor + offset;
        factor = IDCU_11_ALCDrvrCfmONOFFsts.factor;
        offset = IDCU_11_ALCDrvrCfmONOFFsts.offset;
        msg.IDCU_11_ALCDrvrCfmONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ALCDrvrCfmONOFFsts)>::type*>(&IDCU_11_ALCDrvrCfmONOFFsts.signal);
        msg.IDCU_11_ALCDrvrCfmONOFFsts = msg.IDCU_11_ALCDrvrCfmONOFFsts * factor + offset;
        factor = IDCU_11_ALCDrvStysts.factor;
        offset = IDCU_11_ALCDrvStysts.offset;
        msg.IDCU_11_ALCDrvStysts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ALCDrvStysts)>::type*>(&IDCU_11_ALCDrvStysts.signal);
        msg.IDCU_11_ALCDrvStysts = msg.IDCU_11_ALCDrvStysts * factor + offset;
        factor = IDCU_11_FCTBONOFFsts.factor;
        offset = IDCU_11_FCTBONOFFsts.offset;
        msg.IDCU_11_FCTBONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_FCTBONOFFsts)>::type*>(&IDCU_11_FCTBONOFFsts.signal);
        msg.IDCU_11_FCTBONOFFsts = msg.IDCU_11_FCTBONOFFsts * factor + offset;
        factor = IDCU_11_PPMIMod.factor;
        offset = IDCU_11_PPMIMod.offset;
        msg.IDCU_11_PPMIMod = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_PPMIMod)>::type*>(&IDCU_11_PPMIMod.signal);
        msg.IDCU_11_PPMIMod = msg.IDCU_11_PPMIMod * factor + offset;
        factor = IDCU_11_DCLCONOFFsts.factor;
        offset = IDCU_11_DCLCONOFFsts.offset;
        msg.IDCU_11_DCLCONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_DCLCONOFFsts)>::type*>(&IDCU_11_DCLCONOFFsts.signal);
        msg.IDCU_11_DCLCONOFFsts = msg.IDCU_11_DCLCONOFFsts * factor + offset;
        factor = IDCU_11_PrkgIntrptVoice.factor;
        offset = IDCU_11_PrkgIntrptVoice.offset;
        msg.IDCU_11_PrkgIntrptVoice = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_PrkgIntrptVoice)>::type*>(&IDCU_11_PrkgIntrptVoice.signal);
        msg.IDCU_11_PrkgIntrptVoice = msg.IDCU_11_PrkgIntrptVoice * factor + offset;
        factor = IDCU_11_DrvAssiStylests.factor;
        offset = IDCU_11_DrvAssiStylests.offset;
        msg.IDCU_11_DrvAssiStylests = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_DrvAssiStylests)>::type*>(&IDCU_11_DrvAssiStylests.signal);
        msg.IDCU_11_DrvAssiStylests = msg.IDCU_11_DrvAssiStylests * factor + offset;
        factor = IDCU_11_VoiceRem.factor;
        offset = IDCU_11_VoiceRem.offset;
        msg.IDCU_11_VoiceRem = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_VoiceRem)>::type*>(&IDCU_11_VoiceRem.signal);
        msg.IDCU_11_VoiceRem = msg.IDCU_11_VoiceRem * factor + offset;
        factor = IDCU_11_HPAONOFFsts.factor;
        offset = IDCU_11_HPAONOFFsts.offset;
        msg.IDCU_11_HPAONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_HPAONOFFsts)>::type*>(&IDCU_11_HPAONOFFsts.signal);
        msg.IDCU_11_HPAONOFFsts = msg.IDCU_11_HPAONOFFsts * factor + offset;
        factor = IDCU_1_Resd.factor;
        offset = IDCU_1_Resd.offset;
        msg.IDCU_1_Resd = *reinterpret_cast<std::decay<decltype(msg.IDCU_1_Resd)>::type*>(&IDCU_1_Resd.signal);
        msg.IDCU_1_Resd = msg.IDCU_1_Resd * factor + offset;
        factor = IDCU_11_ParkingchimeVoice.factor;
        offset = IDCU_11_ParkingchimeVoice.offset;
        msg.IDCU_11_ParkingchimeVoice = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ParkingchimeVoice)>::type*>(&IDCU_11_ParkingchimeVoice.signal);
        msg.IDCU_11_ParkingchimeVoice = msg.IDCU_11_ParkingchimeVoice * factor + offset;
        factor = IDCU_11_ParkIntSts.factor;
        offset = IDCU_11_ParkIntSts.offset;
        msg.IDCU_11_ParkIntSts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ParkIntSts)>::type*>(&IDCU_11_ParkIntSts.signal);
        msg.IDCU_11_ParkIntSts = msg.IDCU_11_ParkIntSts * factor + offset;
        factor = IDCU_11_StartButtonSts.factor;
        offset = IDCU_11_StartButtonSts.offset;
        msg.IDCU_11_StartButtonSts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_StartButtonSts)>::type*>(&IDCU_11_StartButtonSts.signal);
        msg.IDCU_11_StartButtonSts = msg.IDCU_11_StartButtonSts * factor + offset;
        factor = IDCU_11_ResumeButtonSts.factor;
        offset = IDCU_11_ResumeButtonSts.offset;
        msg.IDCU_11_ResumeButtonSts = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ResumeButtonSts)>::type*>(&IDCU_11_ResumeButtonSts.signal);
        msg.IDCU_11_ResumeButtonSts = msg.IDCU_11_ResumeButtonSts * factor + offset;
        factor = IDCU_11_RPAParkingDriOperateInd.factor;
        offset = IDCU_11_RPAParkingDriOperateInd.offset;
        msg.IDCU_11_RPAParkingDriOperateInd = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_RPAParkingDriOperateInd)>::type*>(&IDCU_11_RPAParkingDriOperateInd.signal);
        msg.IDCU_11_RPAParkingDriOperateInd = msg.IDCU_11_RPAParkingDriOperateInd * factor + offset;
        factor = IDCU_11_ParkingProgressBarInd.factor;
        offset = IDCU_11_ParkingProgressBarInd.offset;
        msg.IDCU_11_ParkingProgressBarInd = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_ParkingProgressBarInd)>::type*>(&IDCU_11_ParkingProgressBarInd.signal);
        msg.IDCU_11_ParkingProgressBarInd = msg.IDCU_11_ParkingProgressBarInd * factor + offset;
        factor = IDCU_11_Resd_2.factor;
        offset = IDCU_11_Resd_2.offset;
        msg.IDCU_11_Resd_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_Resd_2)>::type*>(&IDCU_11_Resd_2.signal);
        msg.IDCU_11_Resd_2 = msg.IDCU_11_Resd_2 * factor + offset;
        factor = IDCU_11_MsgCntr.factor;
        offset = IDCU_11_MsgCntr.offset;
        msg.IDCU_11_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_MsgCntr)>::type*>(&IDCU_11_MsgCntr.signal);
        msg.IDCU_11_MsgCntr = msg.IDCU_11_MsgCntr * factor + offset;
        factor = IDCU_11_CRC.factor;
        offset = IDCU_11_CRC.offset;
        msg.IDCU_11_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_11_CRC)>::type*>(&IDCU_11_CRC.signal);
        msg.IDCU_11_CRC = msg.IDCU_11_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_11_MSG can_struct;
        CanParser2CanStruct_IDCU_11_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_11_MSGMsg>();
        Struct2Proto_IDCU_11_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_11") != nullptr) {
            DFHLOG_I("idcu_11");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_11")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_11");
            return false;
         }
    }
};

struct IDCU_12_Parser {
    SignalParser IDCU_12Rmninfo;

    SignalParser IDCU_12_Resd_1;

    SignalParser IDCU_12CPMod;

    SignalParser IDCU_12FCTAWarnLe;

    SignalParser IDCU_12FCTAWarnRi;

    SignalParser IDCU_12_RmninfoTrig;

    SignalParser IDCU_12_Resd_2;

    SignalParser IDCU_12_MsgCntr;

    SignalParser IDCU_12_CRC;

    IDCU_12_Parser() {
        IDCU_12Rmninfo = CanConfiguration::Instance().SignalParsers()["IDCU_12Rmninfo"];
        IDCU_12_Resd_1 = CanConfiguration::Instance().SignalParsers()["IDCU_12_Resd_1"];
        IDCU_12CPMod = CanConfiguration::Instance().SignalParsers()["IDCU_12CPMod"];
        IDCU_12FCTAWarnLe = CanConfiguration::Instance().SignalParsers()["IDCU_12FCTAWarnLe"];
        IDCU_12FCTAWarnRi = CanConfiguration::Instance().SignalParsers()["IDCU_12FCTAWarnRi"];
        IDCU_12_RmninfoTrig = CanConfiguration::Instance().SignalParsers()["IDCU_12_RmninfoTrig"];
        IDCU_12_Resd_2 = CanConfiguration::Instance().SignalParsers()["IDCU_12_Resd_2"];
        IDCU_12_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_12_MsgCntr"];
        IDCU_12_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_12_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_12Rmninfo.Parser(payload);
        IDCU_12_Resd_1.Parser(payload);
        IDCU_12CPMod.Parser(payload);
        IDCU_12FCTAWarnLe.Parser(payload);
        IDCU_12FCTAWarnRi.Parser(payload);
        IDCU_12_RmninfoTrig.Parser(payload);
        IDCU_12_Resd_2.Parser(payload);
        IDCU_12_MsgCntr.Parser(payload);
        IDCU_12_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_12_MSG(IDCU_12_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_12Rmninfo.factor;
        offset = IDCU_12Rmninfo.offset;
        msg.IDCU_12Rmninfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_12Rmninfo)>::type*>(&IDCU_12Rmninfo.signal);
        msg.IDCU_12Rmninfo = msg.IDCU_12Rmninfo * factor + offset;
        factor = IDCU_12_Resd_1.factor;
        offset = IDCU_12_Resd_1.offset;
        msg.IDCU_12_Resd_1 = *reinterpret_cast<std::decay<decltype(msg.IDCU_12_Resd_1)>::type*>(&IDCU_12_Resd_1.signal);
        msg.IDCU_12_Resd_1 = msg.IDCU_12_Resd_1 * factor + offset;
        factor = IDCU_12CPMod.factor;
        offset = IDCU_12CPMod.offset;
        msg.IDCU_12CPMod = *reinterpret_cast<std::decay<decltype(msg.IDCU_12CPMod)>::type*>(&IDCU_12CPMod.signal);
        msg.IDCU_12CPMod = msg.IDCU_12CPMod * factor + offset;
        factor = IDCU_12FCTAWarnLe.factor;
        offset = IDCU_12FCTAWarnLe.offset;
        msg.IDCU_12FCTAWarnLe = *reinterpret_cast<std::decay<decltype(msg.IDCU_12FCTAWarnLe)>::type*>(&IDCU_12FCTAWarnLe.signal);
        msg.IDCU_12FCTAWarnLe = msg.IDCU_12FCTAWarnLe * factor + offset;
        factor = IDCU_12FCTAWarnRi.factor;
        offset = IDCU_12FCTAWarnRi.offset;
        msg.IDCU_12FCTAWarnRi = *reinterpret_cast<std::decay<decltype(msg.IDCU_12FCTAWarnRi)>::type*>(&IDCU_12FCTAWarnRi.signal);
        msg.IDCU_12FCTAWarnRi = msg.IDCU_12FCTAWarnRi * factor + offset;
        factor = IDCU_12_RmninfoTrig.factor;
        offset = IDCU_12_RmninfoTrig.offset;
        msg.IDCU_12_RmninfoTrig = *reinterpret_cast<std::decay<decltype(msg.IDCU_12_RmninfoTrig)>::type*>(&IDCU_12_RmninfoTrig.signal);
        msg.IDCU_12_RmninfoTrig = msg.IDCU_12_RmninfoTrig * factor + offset;
        factor = IDCU_12_Resd_2.factor;
        offset = IDCU_12_Resd_2.offset;
        msg.IDCU_12_Resd_2 = *reinterpret_cast<std::decay<decltype(msg.IDCU_12_Resd_2)>::type*>(&IDCU_12_Resd_2.signal);
        msg.IDCU_12_Resd_2 = msg.IDCU_12_Resd_2 * factor + offset;
        factor = IDCU_12_MsgCntr.factor;
        offset = IDCU_12_MsgCntr.offset;
        msg.IDCU_12_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_12_MsgCntr)>::type*>(&IDCU_12_MsgCntr.signal);
        msg.IDCU_12_MsgCntr = msg.IDCU_12_MsgCntr * factor + offset;
        factor = IDCU_12_CRC.factor;
        offset = IDCU_12_CRC.offset;
        msg.IDCU_12_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_12_CRC)>::type*>(&IDCU_12_CRC.signal);
        msg.IDCU_12_CRC = msg.IDCU_12_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_12_MSG can_struct;
        CanParser2CanStruct_IDCU_12_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_12_MSGMsg>();
        Struct2Proto_IDCU_12_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_12") != nullptr) {
            DFHLOG_I("idcu_12");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_12")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_12");
            return false;
         }
    }
};

struct IDCU_13_Parser {
    SignalParser IDCU_AEB_TexInfo;

    SignalParser IDCU_TSR_TextInfo;

    SignalParser IDCU_TextInfo_priority;

    SignalParser IDCU_CPMode;

    SignalParser IDCU_FCTB_TexInfo;

    SignalParser IDCU_NOC_TextInfo;

    SignalParser IDCU_ACC_TextInfo;

    SignalParser IDCU_CP_TextInfo;

    SignalParser IDCU_DCLC_TextInfo;

    SignalParser IDCU_HWFailure_TextInfo;

    SignalParser IDCU_ADAS_Sound;

    SignalParser IDCU_LKS_IHC_TextInfo;

    SignalParser IDCU_ADAS_Voice;

    SignalParser IDCU_13_MsgCntr;

    SignalParser IDCU_13_CRC;

    IDCU_13_Parser() {
        IDCU_AEB_TexInfo = CanConfiguration::Instance().SignalParsers()["IDCU_AEB_TexInfo"];
        IDCU_TSR_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_TSR_TextInfo"];
        IDCU_TextInfo_priority = CanConfiguration::Instance().SignalParsers()["IDCU_TextInfo_priority"];
        IDCU_CPMode = CanConfiguration::Instance().SignalParsers()["IDCU_CPMode"];
        IDCU_FCTB_TexInfo = CanConfiguration::Instance().SignalParsers()["IDCU_FCTB_TexInfo"];
        IDCU_NOC_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_NOC_TextInfo"];
        IDCU_ACC_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_ACC_TextInfo"];
        IDCU_CP_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_CP_TextInfo"];
        IDCU_DCLC_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_DCLC_TextInfo"];
        IDCU_HWFailure_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_HWFailure_TextInfo"];
        IDCU_ADAS_Sound = CanConfiguration::Instance().SignalParsers()["IDCU_ADAS_Sound"];
        IDCU_LKS_IHC_TextInfo = CanConfiguration::Instance().SignalParsers()["IDCU_LKS_IHC_TextInfo"];
        IDCU_ADAS_Voice = CanConfiguration::Instance().SignalParsers()["IDCU_ADAS_Voice"];
        IDCU_13_MsgCntr = CanConfiguration::Instance().SignalParsers()["IDCU_13_MsgCntr"];
        IDCU_13_CRC = CanConfiguration::Instance().SignalParsers()["IDCU_13_CRC"];
    }

    void Parser(uint8_t* payload){
        IDCU_AEB_TexInfo.Parser(payload);
        IDCU_TSR_TextInfo.Parser(payload);
        IDCU_TextInfo_priority.Parser(payload);
        IDCU_CPMode.Parser(payload);
        IDCU_FCTB_TexInfo.Parser(payload);
        IDCU_NOC_TextInfo.Parser(payload);
        IDCU_ACC_TextInfo.Parser(payload);
        IDCU_CP_TextInfo.Parser(payload);
        IDCU_DCLC_TextInfo.Parser(payload);
        IDCU_HWFailure_TextInfo.Parser(payload);
        IDCU_ADAS_Sound.Parser(payload);
        IDCU_LKS_IHC_TextInfo.Parser(payload);
        IDCU_ADAS_Voice.Parser(payload);
        IDCU_13_MsgCntr.Parser(payload);
        IDCU_13_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IDCU_13_MSG(IDCU_13_MSG& msg) {
        double factor;
        double offset;
        factor = IDCU_AEB_TexInfo.factor;
        offset = IDCU_AEB_TexInfo.offset;
        msg.IDCU_AEB_TexInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_AEB_TexInfo)>::type*>(&IDCU_AEB_TexInfo.signal);
        msg.IDCU_AEB_TexInfo = msg.IDCU_AEB_TexInfo * factor + offset;
        factor = IDCU_TSR_TextInfo.factor;
        offset = IDCU_TSR_TextInfo.offset;
        msg.IDCU_TSR_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_TSR_TextInfo)>::type*>(&IDCU_TSR_TextInfo.signal);
        msg.IDCU_TSR_TextInfo = msg.IDCU_TSR_TextInfo * factor + offset;
        factor = IDCU_TextInfo_priority.factor;
        offset = IDCU_TextInfo_priority.offset;
        msg.IDCU_TextInfo_priority = *reinterpret_cast<std::decay<decltype(msg.IDCU_TextInfo_priority)>::type*>(&IDCU_TextInfo_priority.signal);
        msg.IDCU_TextInfo_priority = msg.IDCU_TextInfo_priority * factor + offset;
        factor = IDCU_CPMode.factor;
        offset = IDCU_CPMode.offset;
        msg.IDCU_CPMode = *reinterpret_cast<std::decay<decltype(msg.IDCU_CPMode)>::type*>(&IDCU_CPMode.signal);
        msg.IDCU_CPMode = msg.IDCU_CPMode * factor + offset;
        factor = IDCU_FCTB_TexInfo.factor;
        offset = IDCU_FCTB_TexInfo.offset;
        msg.IDCU_FCTB_TexInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_FCTB_TexInfo)>::type*>(&IDCU_FCTB_TexInfo.signal);
        msg.IDCU_FCTB_TexInfo = msg.IDCU_FCTB_TexInfo * factor + offset;
        factor = IDCU_NOC_TextInfo.factor;
        offset = IDCU_NOC_TextInfo.offset;
        msg.IDCU_NOC_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_NOC_TextInfo)>::type*>(&IDCU_NOC_TextInfo.signal);
        msg.IDCU_NOC_TextInfo = msg.IDCU_NOC_TextInfo * factor + offset;
        factor = IDCU_ACC_TextInfo.factor;
        offset = IDCU_ACC_TextInfo.offset;
        msg.IDCU_ACC_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_ACC_TextInfo)>::type*>(&IDCU_ACC_TextInfo.signal);
        msg.IDCU_ACC_TextInfo = msg.IDCU_ACC_TextInfo * factor + offset;
        factor = IDCU_CP_TextInfo.factor;
        offset = IDCU_CP_TextInfo.offset;
        msg.IDCU_CP_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_CP_TextInfo)>::type*>(&IDCU_CP_TextInfo.signal);
        msg.IDCU_CP_TextInfo = msg.IDCU_CP_TextInfo * factor + offset;
        factor = IDCU_DCLC_TextInfo.factor;
        offset = IDCU_DCLC_TextInfo.offset;
        msg.IDCU_DCLC_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_DCLC_TextInfo)>::type*>(&IDCU_DCLC_TextInfo.signal);
        msg.IDCU_DCLC_TextInfo = msg.IDCU_DCLC_TextInfo * factor + offset;
        factor = IDCU_HWFailure_TextInfo.factor;
        offset = IDCU_HWFailure_TextInfo.offset;
        msg.IDCU_HWFailure_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_HWFailure_TextInfo)>::type*>(&IDCU_HWFailure_TextInfo.signal);
        msg.IDCU_HWFailure_TextInfo = msg.IDCU_HWFailure_TextInfo * factor + offset;
        factor = IDCU_ADAS_Sound.factor;
        offset = IDCU_ADAS_Sound.offset;
        msg.IDCU_ADAS_Sound = *reinterpret_cast<std::decay<decltype(msg.IDCU_ADAS_Sound)>::type*>(&IDCU_ADAS_Sound.signal);
        msg.IDCU_ADAS_Sound = msg.IDCU_ADAS_Sound * factor + offset;
        factor = IDCU_LKS_IHC_TextInfo.factor;
        offset = IDCU_LKS_IHC_TextInfo.offset;
        msg.IDCU_LKS_IHC_TextInfo = *reinterpret_cast<std::decay<decltype(msg.IDCU_LKS_IHC_TextInfo)>::type*>(&IDCU_LKS_IHC_TextInfo.signal);
        msg.IDCU_LKS_IHC_TextInfo = msg.IDCU_LKS_IHC_TextInfo * factor + offset;
        factor = IDCU_ADAS_Voice.factor;
        offset = IDCU_ADAS_Voice.offset;
        msg.IDCU_ADAS_Voice = *reinterpret_cast<std::decay<decltype(msg.IDCU_ADAS_Voice)>::type*>(&IDCU_ADAS_Voice.signal);
        msg.IDCU_ADAS_Voice = msg.IDCU_ADAS_Voice * factor + offset;
        factor = IDCU_13_MsgCntr.factor;
        offset = IDCU_13_MsgCntr.offset;
        msg.IDCU_13_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.IDCU_13_MsgCntr)>::type*>(&IDCU_13_MsgCntr.signal);
        msg.IDCU_13_MsgCntr = msg.IDCU_13_MsgCntr * factor + offset;
        factor = IDCU_13_CRC.factor;
        offset = IDCU_13_CRC.offset;
        msg.IDCU_13_CRC = *reinterpret_cast<std::decay<decltype(msg.IDCU_13_CRC)>::type*>(&IDCU_13_CRC.signal);
        msg.IDCU_13_CRC = msg.IDCU_13_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IDCU_13_MSG can_struct;
        CanParser2CanStruct_IDCU_13_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IDCU_13_MSGMsg>();
        Struct2Proto_IDCU_13_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("idcu_13") != nullptr) {
            DFHLOG_I("idcu_13");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("idcu_13")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port idcu_13");
            return false;
         }
    }
};

struct RADAR_1_Parser {
    SignalParser LHRRadarSensorDistance;

    SignalParser RHMRRadarSensorDistance;

    SignalParser LHMRRadarSensorDistance;

    SignalParser RADAR_1_Reserved3;

    SignalParser RHRRadarSensorDistance;

    SignalParser RADAR_1_Reserved4;

    SignalParser LHFRadarSensorDistance;

    SignalParser RADAR_1_Reserved5;

    SignalParser RHFRadarSensorDistance;

    SignalParser RADAR_1_Reserved6;

    SignalParser RHMFRadarSensorDistance;

    SignalParser LHMFRadarSensorDistance;

    SignalParser AudibleBeepRate;

    SignalParser RadarDetectSts;

    SignalParser RadarWorkSts;

    RADAR_1_Parser() {
        LHRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHRRadarSensorDistance"];
        RHMRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHMRRadarSensorDistance"];
        LHMRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHMRRadarSensorDistance"];
        RADAR_1_Reserved3 = CanConfiguration::Instance().SignalParsers()["RADAR_1_Reserved3"];
        RHRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHRRadarSensorDistance"];
        RADAR_1_Reserved4 = CanConfiguration::Instance().SignalParsers()["RADAR_1_Reserved4"];
        LHFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHFRadarSensorDistance"];
        RADAR_1_Reserved5 = CanConfiguration::Instance().SignalParsers()["RADAR_1_Reserved5"];
        RHFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHFRadarSensorDistance"];
        RADAR_1_Reserved6 = CanConfiguration::Instance().SignalParsers()["RADAR_1_Reserved6"];
        RHMFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHMFRadarSensorDistance"];
        LHMFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHMFRadarSensorDistance"];
        AudibleBeepRate = CanConfiguration::Instance().SignalParsers()["AudibleBeepRate"];
        RadarDetectSts = CanConfiguration::Instance().SignalParsers()["RadarDetectSts"];
        RadarWorkSts = CanConfiguration::Instance().SignalParsers()["RadarWorkSts"];
    }

    void Parser(uint8_t* payload){
        LHRRadarSensorDistance.Parser(payload);
        RHMRRadarSensorDistance.Parser(payload);
        LHMRRadarSensorDistance.Parser(payload);
        RADAR_1_Reserved3.Parser(payload);
        RHRRadarSensorDistance.Parser(payload);
        RADAR_1_Reserved4.Parser(payload);
        LHFRadarSensorDistance.Parser(payload);
        RADAR_1_Reserved5.Parser(payload);
        RHFRadarSensorDistance.Parser(payload);
        RADAR_1_Reserved6.Parser(payload);
        RHMFRadarSensorDistance.Parser(payload);
        LHMFRadarSensorDistance.Parser(payload);
        AudibleBeepRate.Parser(payload);
        RadarDetectSts.Parser(payload);
        RadarWorkSts.Parser(payload);
    }

    void CanParser2CanStruct_RADAR_1_MSG(RADAR_1_MSG& msg) {
        double factor;
        double offset;
        factor = LHRRadarSensorDistance.factor;
        offset = LHRRadarSensorDistance.offset;
        msg.LHRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHRRadarSensorDistance)>::type*>(&LHRRadarSensorDistance.signal);
        msg.LHRRadarSensorDistance = msg.LHRRadarSensorDistance * factor + offset;
        factor = RHMRRadarSensorDistance.factor;
        offset = RHMRRadarSensorDistance.offset;
        msg.RHMRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHMRRadarSensorDistance)>::type*>(&RHMRRadarSensorDistance.signal);
        msg.RHMRRadarSensorDistance = msg.RHMRRadarSensorDistance * factor + offset;
        factor = LHMRRadarSensorDistance.factor;
        offset = LHMRRadarSensorDistance.offset;
        msg.LHMRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHMRRadarSensorDistance)>::type*>(&LHMRRadarSensorDistance.signal);
        msg.LHMRRadarSensorDistance = msg.LHMRRadarSensorDistance * factor + offset;
        factor = RADAR_1_Reserved3.factor;
        offset = RADAR_1_Reserved3.offset;
        msg.RADAR_1_Reserved3 = *reinterpret_cast<std::decay<decltype(msg.RADAR_1_Reserved3)>::type*>(&RADAR_1_Reserved3.signal);
        msg.RADAR_1_Reserved3 = msg.RADAR_1_Reserved3 * factor + offset;
        factor = RHRRadarSensorDistance.factor;
        offset = RHRRadarSensorDistance.offset;
        msg.RHRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHRRadarSensorDistance)>::type*>(&RHRRadarSensorDistance.signal);
        msg.RHRRadarSensorDistance = msg.RHRRadarSensorDistance * factor + offset;
        factor = RADAR_1_Reserved4.factor;
        offset = RADAR_1_Reserved4.offset;
        msg.RADAR_1_Reserved4 = *reinterpret_cast<std::decay<decltype(msg.RADAR_1_Reserved4)>::type*>(&RADAR_1_Reserved4.signal);
        msg.RADAR_1_Reserved4 = msg.RADAR_1_Reserved4 * factor + offset;
        factor = LHFRadarSensorDistance.factor;
        offset = LHFRadarSensorDistance.offset;
        msg.LHFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHFRadarSensorDistance)>::type*>(&LHFRadarSensorDistance.signal);
        msg.LHFRadarSensorDistance = msg.LHFRadarSensorDistance * factor + offset;
        factor = RADAR_1_Reserved5.factor;
        offset = RADAR_1_Reserved5.offset;
        msg.RADAR_1_Reserved5 = *reinterpret_cast<std::decay<decltype(msg.RADAR_1_Reserved5)>::type*>(&RADAR_1_Reserved5.signal);
        msg.RADAR_1_Reserved5 = msg.RADAR_1_Reserved5 * factor + offset;
        factor = RHFRadarSensorDistance.factor;
        offset = RHFRadarSensorDistance.offset;
        msg.RHFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHFRadarSensorDistance)>::type*>(&RHFRadarSensorDistance.signal);
        msg.RHFRadarSensorDistance = msg.RHFRadarSensorDistance * factor + offset;
        factor = RADAR_1_Reserved6.factor;
        offset = RADAR_1_Reserved6.offset;
        msg.RADAR_1_Reserved6 = *reinterpret_cast<std::decay<decltype(msg.RADAR_1_Reserved6)>::type*>(&RADAR_1_Reserved6.signal);
        msg.RADAR_1_Reserved6 = msg.RADAR_1_Reserved6 * factor + offset;
        factor = RHMFRadarSensorDistance.factor;
        offset = RHMFRadarSensorDistance.offset;
        msg.RHMFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHMFRadarSensorDistance)>::type*>(&RHMFRadarSensorDistance.signal);
        msg.RHMFRadarSensorDistance = msg.RHMFRadarSensorDistance * factor + offset;
        factor = LHMFRadarSensorDistance.factor;
        offset = LHMFRadarSensorDistance.offset;
        msg.LHMFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHMFRadarSensorDistance)>::type*>(&LHMFRadarSensorDistance.signal);
        msg.LHMFRadarSensorDistance = msg.LHMFRadarSensorDistance * factor + offset;
        factor = AudibleBeepRate.factor;
        offset = AudibleBeepRate.offset;
        msg.AudibleBeepRate = *reinterpret_cast<std::decay<decltype(msg.AudibleBeepRate)>::type*>(&AudibleBeepRate.signal);
        msg.AudibleBeepRate = msg.AudibleBeepRate * factor + offset;
        factor = RadarDetectSts.factor;
        offset = RadarDetectSts.offset;
        msg.RadarDetectSts = *reinterpret_cast<std::decay<decltype(msg.RadarDetectSts)>::type*>(&RadarDetectSts.signal);
        msg.RadarDetectSts = msg.RadarDetectSts * factor + offset;
        factor = RadarWorkSts.factor;
        offset = RadarWorkSts.offset;
        msg.RadarWorkSts = *reinterpret_cast<std::decay<decltype(msg.RadarWorkSts)>::type*>(&RadarWorkSts.signal);
        msg.RadarWorkSts = msg.RadarWorkSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        RADAR_1_MSG can_struct;
        CanParser2CanStruct_RADAR_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::RADAR_1_MSGMsg>();
        Struct2Proto_RADAR_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("radar_1") != nullptr) {
            DFHLOG_I("radar_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("radar_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port radar_1");
            return false;
         }
    }
};

struct RADAR_2_Parser {
    SignalParser RHSRRadarSensorDistance;

    SignalParser LHSRRadarSensorDistance;

    SignalParser RHSFRadarSensorDistance;

    SignalParser RearPDCObjectDistance;

    SignalParser FrontPDCObjectDistance;

    SignalParser LHSFRadarSensorDistance;

    RADAR_2_Parser() {
        RHSRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHSRRadarSensorDistance"];
        LHSRRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHSRRadarSensorDistance"];
        RHSFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["RHSFRadarSensorDistance"];
        RearPDCObjectDistance = CanConfiguration::Instance().SignalParsers()["RearPDCObjectDistance"];
        FrontPDCObjectDistance = CanConfiguration::Instance().SignalParsers()["FrontPDCObjectDistance"];
        LHSFRadarSensorDistance = CanConfiguration::Instance().SignalParsers()["LHSFRadarSensorDistance"];
    }

    void Parser(uint8_t* payload){
        RHSRRadarSensorDistance.Parser(payload);
        LHSRRadarSensorDistance.Parser(payload);
        RHSFRadarSensorDistance.Parser(payload);
        RearPDCObjectDistance.Parser(payload);
        FrontPDCObjectDistance.Parser(payload);
        LHSFRadarSensorDistance.Parser(payload);
    }

    void CanParser2CanStruct_RADAR_2_MSG(RADAR_2_MSG& msg) {
        double factor;
        double offset;
        factor = RHSRRadarSensorDistance.factor;
        offset = RHSRRadarSensorDistance.offset;
        msg.RHSRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHSRRadarSensorDistance)>::type*>(&RHSRRadarSensorDistance.signal);
        msg.RHSRRadarSensorDistance = msg.RHSRRadarSensorDistance * factor + offset;
        factor = LHSRRadarSensorDistance.factor;
        offset = LHSRRadarSensorDistance.offset;
        msg.LHSRRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHSRRadarSensorDistance)>::type*>(&LHSRRadarSensorDistance.signal);
        msg.LHSRRadarSensorDistance = msg.LHSRRadarSensorDistance * factor + offset;
        factor = RHSFRadarSensorDistance.factor;
        offset = RHSFRadarSensorDistance.offset;
        msg.RHSFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.RHSFRadarSensorDistance)>::type*>(&RHSFRadarSensorDistance.signal);
        msg.RHSFRadarSensorDistance = msg.RHSFRadarSensorDistance * factor + offset;
        factor = RearPDCObjectDistance.factor;
        offset = RearPDCObjectDistance.offset;
        msg.RearPDCObjectDistance = *reinterpret_cast<std::decay<decltype(msg.RearPDCObjectDistance)>::type*>(&RearPDCObjectDistance.signal);
        msg.RearPDCObjectDistance = msg.RearPDCObjectDistance * factor + offset;
        factor = FrontPDCObjectDistance.factor;
        offset = FrontPDCObjectDistance.offset;
        msg.FrontPDCObjectDistance = *reinterpret_cast<std::decay<decltype(msg.FrontPDCObjectDistance)>::type*>(&FrontPDCObjectDistance.signal);
        msg.FrontPDCObjectDistance = msg.FrontPDCObjectDistance * factor + offset;
        factor = LHSFRadarSensorDistance.factor;
        offset = LHSFRadarSensorDistance.offset;
        msg.LHSFRadarSensorDistance = *reinterpret_cast<std::decay<decltype(msg.LHSFRadarSensorDistance)>::type*>(&LHSFRadarSensorDistance.signal);
        msg.LHSFRadarSensorDistance = msg.LHSFRadarSensorDistance * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        RADAR_2_MSG can_struct;
        CanParser2CanStruct_RADAR_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::RADAR_2_MSGMsg>();
        Struct2Proto_RADAR_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("radar_2") != nullptr) {
            DFHLOG_I("radar_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("radar_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port radar_2");
            return false;
         }
    }
};

struct RLCR_2_Parser {
    SignalParser RLCR_2_Resd1;

    SignalParser RLCR_2_RAEBReq;

    SignalParser RLCR_2_RAEBONOFFSts;

    SignalParser RLCR_2_RCTBONOFFSts;

    SignalParser RLCR_2_RAEBCtrlA;

    SignalParser RLCR_2_Resd4;

    SignalParser RLCR_2_RCTBReq;

    SignalParser RLCR_2_Resd2;

    SignalParser RLCR_2_RCTBCtrlA;

    SignalParser RLCR_2_Resd3;

    SignalParser RLCR_2_MsgCntr;

    SignalParser RLCR_2_CRC;

    RLCR_2_Parser() {
        RLCR_2_Resd1 = CanConfiguration::Instance().SignalParsers()["RLCR_2_Resd1"];
        RLCR_2_RAEBReq = CanConfiguration::Instance().SignalParsers()["RLCR_2_RAEBReq"];
        RLCR_2_RAEBONOFFSts = CanConfiguration::Instance().SignalParsers()["RLCR_2_RAEBONOFFSts"];
        RLCR_2_RCTBONOFFSts = CanConfiguration::Instance().SignalParsers()["RLCR_2_RCTBONOFFSts"];
        RLCR_2_RAEBCtrlA = CanConfiguration::Instance().SignalParsers()["RLCR_2_RAEBCtrlA"];
        RLCR_2_Resd4 = CanConfiguration::Instance().SignalParsers()["RLCR_2_Resd4"];
        RLCR_2_RCTBReq = CanConfiguration::Instance().SignalParsers()["RLCR_2_RCTBReq"];
        RLCR_2_Resd2 = CanConfiguration::Instance().SignalParsers()["RLCR_2_Resd2"];
        RLCR_2_RCTBCtrlA = CanConfiguration::Instance().SignalParsers()["RLCR_2_RCTBCtrlA"];
        RLCR_2_Resd3 = CanConfiguration::Instance().SignalParsers()["RLCR_2_Resd3"];
        RLCR_2_MsgCntr = CanConfiguration::Instance().SignalParsers()["RLCR_2_MsgCntr"];
        RLCR_2_CRC = CanConfiguration::Instance().SignalParsers()["RLCR_2_CRC"];
    }

    void Parser(uint8_t* payload){
        RLCR_2_Resd1.Parser(payload);
        RLCR_2_RAEBReq.Parser(payload);
        RLCR_2_RAEBONOFFSts.Parser(payload);
        RLCR_2_RCTBONOFFSts.Parser(payload);
        RLCR_2_RAEBCtrlA.Parser(payload);
        RLCR_2_Resd4.Parser(payload);
        RLCR_2_RCTBReq.Parser(payload);
        RLCR_2_Resd2.Parser(payload);
        RLCR_2_RCTBCtrlA.Parser(payload);
        RLCR_2_Resd3.Parser(payload);
        RLCR_2_MsgCntr.Parser(payload);
        RLCR_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_RLCR_2_MSG(RLCR_2_MSG& msg) {
        double factor;
        double offset;
        factor = RLCR_2_Resd1.factor;
        offset = RLCR_2_Resd1.offset;
        msg.RLCR_2_Resd1 = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_Resd1)>::type*>(&RLCR_2_Resd1.signal);
        msg.RLCR_2_Resd1 = msg.RLCR_2_Resd1 * factor + offset;
        factor = RLCR_2_RAEBReq.factor;
        offset = RLCR_2_RAEBReq.offset;
        msg.RLCR_2_RAEBReq = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RAEBReq)>::type*>(&RLCR_2_RAEBReq.signal);
        msg.RLCR_2_RAEBReq = msg.RLCR_2_RAEBReq * factor + offset;
        factor = RLCR_2_RAEBONOFFSts.factor;
        offset = RLCR_2_RAEBONOFFSts.offset;
        msg.RLCR_2_RAEBONOFFSts = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RAEBONOFFSts)>::type*>(&RLCR_2_RAEBONOFFSts.signal);
        msg.RLCR_2_RAEBONOFFSts = msg.RLCR_2_RAEBONOFFSts * factor + offset;
        factor = RLCR_2_RCTBONOFFSts.factor;
        offset = RLCR_2_RCTBONOFFSts.offset;
        msg.RLCR_2_RCTBONOFFSts = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RCTBONOFFSts)>::type*>(&RLCR_2_RCTBONOFFSts.signal);
        msg.RLCR_2_RCTBONOFFSts = msg.RLCR_2_RCTBONOFFSts * factor + offset;
        factor = RLCR_2_RAEBCtrlA.factor;
        offset = RLCR_2_RAEBCtrlA.offset;
        msg.RLCR_2_RAEBCtrlA = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RAEBCtrlA)>::type*>(&RLCR_2_RAEBCtrlA.signal);
        msg.RLCR_2_RAEBCtrlA = msg.RLCR_2_RAEBCtrlA * factor + offset;
        factor = RLCR_2_Resd4.factor;
        offset = RLCR_2_Resd4.offset;
        msg.RLCR_2_Resd4 = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_Resd4)>::type*>(&RLCR_2_Resd4.signal);
        msg.RLCR_2_Resd4 = msg.RLCR_2_Resd4 * factor + offset;
        factor = RLCR_2_RCTBReq.factor;
        offset = RLCR_2_RCTBReq.offset;
        msg.RLCR_2_RCTBReq = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RCTBReq)>::type*>(&RLCR_2_RCTBReq.signal);
        msg.RLCR_2_RCTBReq = msg.RLCR_2_RCTBReq * factor + offset;
        factor = RLCR_2_Resd2.factor;
        offset = RLCR_2_Resd2.offset;
        msg.RLCR_2_Resd2 = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_Resd2)>::type*>(&RLCR_2_Resd2.signal);
        msg.RLCR_2_Resd2 = msg.RLCR_2_Resd2 * factor + offset;
        factor = RLCR_2_RCTBCtrlA.factor;
        offset = RLCR_2_RCTBCtrlA.offset;
        msg.RLCR_2_RCTBCtrlA = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_RCTBCtrlA)>::type*>(&RLCR_2_RCTBCtrlA.signal);
        msg.RLCR_2_RCTBCtrlA = msg.RLCR_2_RCTBCtrlA * factor + offset;
        factor = RLCR_2_Resd3.factor;
        offset = RLCR_2_Resd3.offset;
        msg.RLCR_2_Resd3 = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_Resd3)>::type*>(&RLCR_2_Resd3.signal);
        msg.RLCR_2_Resd3 = msg.RLCR_2_Resd3 * factor + offset;
        factor = RLCR_2_MsgCntr.factor;
        offset = RLCR_2_MsgCntr.offset;
        msg.RLCR_2_MsgCntr = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_MsgCntr)>::type*>(&RLCR_2_MsgCntr.signal);
        msg.RLCR_2_MsgCntr = msg.RLCR_2_MsgCntr * factor + offset;
        factor = RLCR_2_CRC.factor;
        offset = RLCR_2_CRC.offset;
        msg.RLCR_2_CRC = *reinterpret_cast<std::decay<decltype(msg.RLCR_2_CRC)>::type*>(&RLCR_2_CRC.signal);
        msg.RLCR_2_CRC = msg.RLCR_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        RLCR_2_MSG can_struct;
        CanParser2CanStruct_RLCR_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::RLCR_2_MSGMsg>();
        Struct2Proto_RLCR_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("rlcr_2") != nullptr) {
            DFHLOG_I("rlcr_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("rlcr_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port rlcr_2");
            return false;
         }
    }
};

struct NMm_IDCU_Parser {
    SignalParser srcNodeID_IDCU;

    SignalParser RMR_IDCU;

    SignalParser NMm_IDCU_Reserved1;

    SignalParser usrData0_IDCU;

    SignalParser IGNITION_WAKEUP_IDCU;

    SignalParser RESET_WAKEUP_IDCU;

    SignalParser NETWORK_WAKEUP_IDCU;

    SignalParser ECUSPEC_WAKEUP_IDCU;

    SignalParser NETWORK_AWAKE_IDCU;

    SignalParser IGNITION_AWAKE_IDCU;

    SignalParser DIAGNOSTIC_AWAKE_IDCU;

    SignalParser ECUSPEC_AWAKE_IDCU;

    SignalParser usrData2_IDCU;

    SignalParser usrData3_IDCU;

    SignalParser usrData4_IDCU;

    SignalParser usrData5_IDCU;

    NMm_IDCU_Parser() {
        srcNodeID_IDCU = CanConfiguration::Instance().SignalParsers()["srcNodeID_IDCU"];
        RMR_IDCU = CanConfiguration::Instance().SignalParsers()["RMR_IDCU"];
        NMm_IDCU_Reserved1 = CanConfiguration::Instance().SignalParsers()["NMm_IDCU_Reserved1"];
        usrData0_IDCU = CanConfiguration::Instance().SignalParsers()["usrData0_IDCU"];
        IGNITION_WAKEUP_IDCU = CanConfiguration::Instance().SignalParsers()["IGNITION_WAKEUP_IDCU"];
        RESET_WAKEUP_IDCU = CanConfiguration::Instance().SignalParsers()["RESET_WAKEUP_IDCU"];
        NETWORK_WAKEUP_IDCU = CanConfiguration::Instance().SignalParsers()["NETWORK_WAKEUP_IDCU"];
        ECUSPEC_WAKEUP_IDCU = CanConfiguration::Instance().SignalParsers()["ECUSPEC_WAKEUP_IDCU"];
        NETWORK_AWAKE_IDCU = CanConfiguration::Instance().SignalParsers()["NETWORK_AWAKE_IDCU"];
        IGNITION_AWAKE_IDCU = CanConfiguration::Instance().SignalParsers()["IGNITION_AWAKE_IDCU"];
        DIAGNOSTIC_AWAKE_IDCU = CanConfiguration::Instance().SignalParsers()["DIAGNOSTIC_AWAKE_IDCU"];
        ECUSPEC_AWAKE_IDCU = CanConfiguration::Instance().SignalParsers()["ECUSPEC_AWAKE_IDCU"];
        usrData2_IDCU = CanConfiguration::Instance().SignalParsers()["usrData2_IDCU"];
        usrData3_IDCU = CanConfiguration::Instance().SignalParsers()["usrData3_IDCU"];
        usrData4_IDCU = CanConfiguration::Instance().SignalParsers()["usrData4_IDCU"];
        usrData5_IDCU = CanConfiguration::Instance().SignalParsers()["usrData5_IDCU"];
    }

    void Parser(uint8_t* payload){
        srcNodeID_IDCU.Parser(payload);
        RMR_IDCU.Parser(payload);
        NMm_IDCU_Reserved1.Parser(payload);
        usrData0_IDCU.Parser(payload);
        IGNITION_WAKEUP_IDCU.Parser(payload);
        RESET_WAKEUP_IDCU.Parser(payload);
        NETWORK_WAKEUP_IDCU.Parser(payload);
        ECUSPEC_WAKEUP_IDCU.Parser(payload);
        NETWORK_AWAKE_IDCU.Parser(payload);
        IGNITION_AWAKE_IDCU.Parser(payload);
        DIAGNOSTIC_AWAKE_IDCU.Parser(payload);
        ECUSPEC_AWAKE_IDCU.Parser(payload);
        usrData2_IDCU.Parser(payload);
        usrData3_IDCU.Parser(payload);
        usrData4_IDCU.Parser(payload);
        usrData5_IDCU.Parser(payload);
    }

    void CanParser2CanStruct_NMm_IDCU_MSG(NMm_IDCU_MSG& msg) {
        double factor;
        double offset;
        factor = srcNodeID_IDCU.factor;
        offset = srcNodeID_IDCU.offset;
        msg.srcNodeID_IDCU = *reinterpret_cast<std::decay<decltype(msg.srcNodeID_IDCU)>::type*>(&srcNodeID_IDCU.signal);
        msg.srcNodeID_IDCU = msg.srcNodeID_IDCU * factor + offset;
        factor = RMR_IDCU.factor;
        offset = RMR_IDCU.offset;
        msg.RMR_IDCU = *reinterpret_cast<std::decay<decltype(msg.RMR_IDCU)>::type*>(&RMR_IDCU.signal);
        msg.RMR_IDCU = msg.RMR_IDCU * factor + offset;
        factor = NMm_IDCU_Reserved1.factor;
        offset = NMm_IDCU_Reserved1.offset;
        msg.NMm_IDCU_Reserved1 = *reinterpret_cast<std::decay<decltype(msg.NMm_IDCU_Reserved1)>::type*>(&NMm_IDCU_Reserved1.signal);
        msg.NMm_IDCU_Reserved1 = msg.NMm_IDCU_Reserved1 * factor + offset;
        factor = usrData0_IDCU.factor;
        offset = usrData0_IDCU.offset;
        msg.usrData0_IDCU = *reinterpret_cast<std::decay<decltype(msg.usrData0_IDCU)>::type*>(&usrData0_IDCU.signal);
        msg.usrData0_IDCU = msg.usrData0_IDCU * factor + offset;
        factor = IGNITION_WAKEUP_IDCU.factor;
        offset = IGNITION_WAKEUP_IDCU.offset;
        msg.IGNITION_WAKEUP_IDCU = *reinterpret_cast<std::decay<decltype(msg.IGNITION_WAKEUP_IDCU)>::type*>(&IGNITION_WAKEUP_IDCU.signal);
        msg.IGNITION_WAKEUP_IDCU = msg.IGNITION_WAKEUP_IDCU * factor + offset;
        factor = RESET_WAKEUP_IDCU.factor;
        offset = RESET_WAKEUP_IDCU.offset;
        msg.RESET_WAKEUP_IDCU = *reinterpret_cast<std::decay<decltype(msg.RESET_WAKEUP_IDCU)>::type*>(&RESET_WAKEUP_IDCU.signal);
        msg.RESET_WAKEUP_IDCU = msg.RESET_WAKEUP_IDCU * factor + offset;
        factor = NETWORK_WAKEUP_IDCU.factor;
        offset = NETWORK_WAKEUP_IDCU.offset;
        msg.NETWORK_WAKEUP_IDCU = *reinterpret_cast<std::decay<decltype(msg.NETWORK_WAKEUP_IDCU)>::type*>(&NETWORK_WAKEUP_IDCU.signal);
        msg.NETWORK_WAKEUP_IDCU = msg.NETWORK_WAKEUP_IDCU * factor + offset;
        factor = ECUSPEC_WAKEUP_IDCU.factor;
        offset = ECUSPEC_WAKEUP_IDCU.offset;
        msg.ECUSPEC_WAKEUP_IDCU = *reinterpret_cast<std::decay<decltype(msg.ECUSPEC_WAKEUP_IDCU)>::type*>(&ECUSPEC_WAKEUP_IDCU.signal);
        msg.ECUSPEC_WAKEUP_IDCU = msg.ECUSPEC_WAKEUP_IDCU * factor + offset;
        factor = NETWORK_AWAKE_IDCU.factor;
        offset = NETWORK_AWAKE_IDCU.offset;
        msg.NETWORK_AWAKE_IDCU = *reinterpret_cast<std::decay<decltype(msg.NETWORK_AWAKE_IDCU)>::type*>(&NETWORK_AWAKE_IDCU.signal);
        msg.NETWORK_AWAKE_IDCU = msg.NETWORK_AWAKE_IDCU * factor + offset;
        factor = IGNITION_AWAKE_IDCU.factor;
        offset = IGNITION_AWAKE_IDCU.offset;
        msg.IGNITION_AWAKE_IDCU = *reinterpret_cast<std::decay<decltype(msg.IGNITION_AWAKE_IDCU)>::type*>(&IGNITION_AWAKE_IDCU.signal);
        msg.IGNITION_AWAKE_IDCU = msg.IGNITION_AWAKE_IDCU * factor + offset;
        factor = DIAGNOSTIC_AWAKE_IDCU.factor;
        offset = DIAGNOSTIC_AWAKE_IDCU.offset;
        msg.DIAGNOSTIC_AWAKE_IDCU = *reinterpret_cast<std::decay<decltype(msg.DIAGNOSTIC_AWAKE_IDCU)>::type*>(&DIAGNOSTIC_AWAKE_IDCU.signal);
        msg.DIAGNOSTIC_AWAKE_IDCU = msg.DIAGNOSTIC_AWAKE_IDCU * factor + offset;
        factor = ECUSPEC_AWAKE_IDCU.factor;
        offset = ECUSPEC_AWAKE_IDCU.offset;
        msg.ECUSPEC_AWAKE_IDCU = *reinterpret_cast<std::decay<decltype(msg.ECUSPEC_AWAKE_IDCU)>::type*>(&ECUSPEC_AWAKE_IDCU.signal);
        msg.ECUSPEC_AWAKE_IDCU = msg.ECUSPEC_AWAKE_IDCU * factor + offset;
        factor = usrData2_IDCU.factor;
        offset = usrData2_IDCU.offset;
        msg.usrData2_IDCU = *reinterpret_cast<std::decay<decltype(msg.usrData2_IDCU)>::type*>(&usrData2_IDCU.signal);
        msg.usrData2_IDCU = msg.usrData2_IDCU * factor + offset;
        factor = usrData3_IDCU.factor;
        offset = usrData3_IDCU.offset;
        msg.usrData3_IDCU = *reinterpret_cast<std::decay<decltype(msg.usrData3_IDCU)>::type*>(&usrData3_IDCU.signal);
        msg.usrData3_IDCU = msg.usrData3_IDCU * factor + offset;
        factor = usrData4_IDCU.factor;
        offset = usrData4_IDCU.offset;
        msg.usrData4_IDCU = *reinterpret_cast<std::decay<decltype(msg.usrData4_IDCU)>::type*>(&usrData4_IDCU.signal);
        msg.usrData4_IDCU = msg.usrData4_IDCU * factor + offset;
        factor = usrData5_IDCU.factor;
        offset = usrData5_IDCU.offset;
        msg.usrData5_IDCU = *reinterpret_cast<std::decay<decltype(msg.usrData5_IDCU)>::type*>(&usrData5_IDCU.signal);
        msg.usrData5_IDCU = msg.usrData5_IDCU * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        NMm_IDCU_MSG can_struct;
        CanParser2CanStruct_NMm_IDCU_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::NMm_IDCU_MSGMsg>();
        Struct2Proto_NMm_IDCU_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("nmm_idcu") != nullptr) {
            DFHLOG_I("nmm_idcu");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("nmm_idcu")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port nmm_idcu");
            return false;
         }
    }
};

struct XCP_FCM_RES_Parser {
    SignalParser XCP_FCM_RES;

    XCP_FCM_RES_Parser() {
        XCP_FCM_RES = CanConfiguration::Instance().SignalParsers()["XCP_FCM_RES"];
    }

    void Parser(uint8_t* payload){
        XCP_FCM_RES.Parser(payload);
    }

    void CanParser2CanStruct_XCP_FCM_RES_MSG(XCP_FCM_RES_MSG& msg) {
        double factor;
        double offset;
        factor = XCP_FCM_RES.factor;
        offset = XCP_FCM_RES.offset;
        msg.XCP_FCM_RES = *reinterpret_cast<std::decay<decltype(msg.XCP_FCM_RES)>::type*>(&XCP_FCM_RES.signal);
        msg.XCP_FCM_RES = msg.XCP_FCM_RES * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        XCP_FCM_RES_MSG can_struct;
        CanParser2CanStruct_XCP_FCM_RES_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::XCP_FCM_RES_MSGMsg>();
        Struct2Proto_XCP_FCM_RES_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("xcp_fcm_res") != nullptr) {
            DFHLOG_I("xcp_fcm_res");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("xcp_fcm_res")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port xcp_fcm_res");
            return false;
         }
    }
};

struct Diag_IDCU_RES_Parser {
    SignalParser Diag_IDCU_RES;

    Diag_IDCU_RES_Parser() {
        Diag_IDCU_RES = CanConfiguration::Instance().SignalParsers()["Diag_IDCU_RES"];
    }

    void Parser(uint8_t* payload){
        Diag_IDCU_RES.Parser(payload);
    }

    void CanParser2CanStruct_Diag_IDCU_RES_MSG(Diag_IDCU_RES_MSG& msg) {
        double factor;
        double offset;
        factor = Diag_IDCU_RES.factor;
        offset = Diag_IDCU_RES.offset;
        msg.Diag_IDCU_RES = *reinterpret_cast<std::decay<decltype(msg.Diag_IDCU_RES)>::type*>(&Diag_IDCU_RES.signal);
        msg.Diag_IDCU_RES = msg.Diag_IDCU_RES * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        Diag_IDCU_RES_MSG can_struct;
        CanParser2CanStruct_Diag_IDCU_RES_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::Diag_IDCU_RES_MSGMsg>();
        Struct2Proto_Diag_IDCU_RES_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("diag_idcu_res") != nullptr) {
            DFHLOG_I("diag_idcu_res");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("diag_idcu_res")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port diag_idcu_res");
            return false;
         }
    }
};

struct ABM_1_Parser {
    SignalParser ABM_1_MessageCounter;

    SignalParser PsngrSeatBeltWarning;

    SignalParser ABM_1_CheckSum;

    SignalParser CrashOutputSts;

    ABM_1_Parser() {
        ABM_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABM_1_MessageCounter"];
        PsngrSeatBeltWarning = CanConfiguration::Instance().SignalParsers()["PsngrSeatBeltWarning"];
        ABM_1_CheckSum = CanConfiguration::Instance().SignalParsers()["ABM_1_CheckSum"];
        CrashOutputSts = CanConfiguration::Instance().SignalParsers()["CrashOutputSts"];
    }

    void Parser(uint8_t* payload){
        ABM_1_MessageCounter.Parser(payload);
        PsngrSeatBeltWarning.Parser(payload);
        ABM_1_CheckSum.Parser(payload);
        CrashOutputSts.Parser(payload);
    }

    void CanParser2CanStruct_ABM_1_MSG(ABM_1_MSG& msg) {
        double factor;
        double offset;
        factor = ABM_1_MessageCounter.factor;
        offset = ABM_1_MessageCounter.offset;
        msg.ABM_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABM_1_MessageCounter)>::type*>(&ABM_1_MessageCounter.signal);
        msg.ABM_1_MessageCounter = msg.ABM_1_MessageCounter * factor + offset;
        factor = PsngrSeatBeltWarning.factor;
        offset = PsngrSeatBeltWarning.offset;
        msg.PsngrSeatBeltWarning = *reinterpret_cast<std::decay<decltype(msg.PsngrSeatBeltWarning)>::type*>(&PsngrSeatBeltWarning.signal);
        msg.PsngrSeatBeltWarning = msg.PsngrSeatBeltWarning * factor + offset;
        factor = ABM_1_CheckSum.factor;
        offset = ABM_1_CheckSum.offset;
        msg.ABM_1_CheckSum = *reinterpret_cast<std::decay<decltype(msg.ABM_1_CheckSum)>::type*>(&ABM_1_CheckSum.signal);
        msg.ABM_1_CheckSum = msg.ABM_1_CheckSum * factor + offset;
        factor = CrashOutputSts.factor;
        offset = CrashOutputSts.offset;
        msg.CrashOutputSts = *reinterpret_cast<std::decay<decltype(msg.CrashOutputSts)>::type*>(&CrashOutputSts.signal);
        msg.CrashOutputSts = msg.CrashOutputSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABM_1_MSG can_struct;
        CanParser2CanStruct_ABM_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABM_1_MSGMsg>();
        Struct2Proto_ABM_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abm_1") != nullptr) {
            DFHLOG_I("abm_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abm_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abm_1");
            return false;
         }
    }
};

struct ABS_ESP_1_Parser {
    SignalParser ESP_APA_GearBoxEnable;

    SignalParser ABS_ESP_1_EBDFailSts;

    SignalParser ESP_APA_Target_Gear_Request;

    SignalParser ABS_ESP_1_ABSFailSts;

    SignalParser ABS_ESP_1_ABSActive;

    SignalParser ABS_ESP_1_VDCFailSts;

    SignalParser ABS_ESP_1_VDCActive;

    SignalParser ABS_ESP_1_TCSFailSts;

    SignalParser ABS_ESP_1_TCSActive;

    SignalParser ABS_ESP_1_PressureMasterCylinder;

    SignalParser ESP1_PressureMasCylindValidData;

    SignalParser IPB_SimulatorPressure;

    SignalParser IPB_SimulatorPressureStatus;

    SignalParser ESP1_VehicleSpeedVSOSigValidData;

    SignalParser ABS_ESP_1_VehicleSpeedVSOSig;

    SignalParser ABS_ESP_1_Checksum;

    SignalParser ABS_ESP_1_HDCCtrlSts;

    SignalParser ABS_ESP_1_HDCFailSts;

    SignalParser ABS_ESP_1_MessageCounter;

    SignalParser ABS_ESP_1_ESPSwitchStatus;

    SignalParser SwitchOffCruiseControl;

    ABS_ESP_1_Parser() {
        ESP_APA_GearBoxEnable = CanConfiguration::Instance().SignalParsers()["ESP_APA_GearBoxEnable"];
        ABS_ESP_1_EBDFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_EBDFailSts"];
        ESP_APA_Target_Gear_Request = CanConfiguration::Instance().SignalParsers()["ESP_APA_Target_Gear_Request"];
        ABS_ESP_1_ABSFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_ABSFailSts"];
        ABS_ESP_1_ABSActive = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_ABSActive"];
        ABS_ESP_1_VDCFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_VDCFailSts"];
        ABS_ESP_1_VDCActive = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_VDCActive"];
        ABS_ESP_1_TCSFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_TCSFailSts"];
        ABS_ESP_1_TCSActive = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_TCSActive"];
        ABS_ESP_1_PressureMasterCylinder = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_PressureMasterCylinder"];
        ESP1_PressureMasCylindValidData = CanConfiguration::Instance().SignalParsers()["ESP1_PressureMasCylindValidData"];
        IPB_SimulatorPressure = CanConfiguration::Instance().SignalParsers()["IPB_SimulatorPressure"];
        IPB_SimulatorPressureStatus = CanConfiguration::Instance().SignalParsers()["IPB_SimulatorPressureStatus"];
        ESP1_VehicleSpeedVSOSigValidData = CanConfiguration::Instance().SignalParsers()["ESP1_VehicleSpeedVSOSigValidData"];
        ABS_ESP_1_VehicleSpeedVSOSig = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_VehicleSpeedVSOSig"];
        ABS_ESP_1_Checksum = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_Checksum"];
        ABS_ESP_1_HDCCtrlSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_HDCCtrlSts"];
        ABS_ESP_1_HDCFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_HDCFailSts"];
        ABS_ESP_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_MessageCounter"];
        ABS_ESP_1_ESPSwitchStatus = CanConfiguration::Instance().SignalParsers()["ABS_ESP_1_ESPSwitchStatus"];
        SwitchOffCruiseControl = CanConfiguration::Instance().SignalParsers()["SwitchOffCruiseControl"];
    }

    void Parser(uint8_t* payload){
        ESP_APA_GearBoxEnable.Parser(payload);
        ABS_ESP_1_EBDFailSts.Parser(payload);
        ESP_APA_Target_Gear_Request.Parser(payload);
        ABS_ESP_1_ABSFailSts.Parser(payload);
        ABS_ESP_1_ABSActive.Parser(payload);
        ABS_ESP_1_VDCFailSts.Parser(payload);
        ABS_ESP_1_VDCActive.Parser(payload);
        ABS_ESP_1_TCSFailSts.Parser(payload);
        ABS_ESP_1_TCSActive.Parser(payload);
        ABS_ESP_1_PressureMasterCylinder.Parser(payload);
        ESP1_PressureMasCylindValidData.Parser(payload);
        IPB_SimulatorPressure.Parser(payload);
        IPB_SimulatorPressureStatus.Parser(payload);
        ESP1_VehicleSpeedVSOSigValidData.Parser(payload);
        ABS_ESP_1_VehicleSpeedVSOSig.Parser(payload);
        ABS_ESP_1_Checksum.Parser(payload);
        ABS_ESP_1_HDCCtrlSts.Parser(payload);
        ABS_ESP_1_HDCFailSts.Parser(payload);
        ABS_ESP_1_MessageCounter.Parser(payload);
        ABS_ESP_1_ESPSwitchStatus.Parser(payload);
        SwitchOffCruiseControl.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_1_MSG(ABS_ESP_1_MSG& msg) {
        double factor;
        double offset;
        factor = ESP_APA_GearBoxEnable.factor;
        offset = ESP_APA_GearBoxEnable.offset;
        msg.ESP_APA_GearBoxEnable = *reinterpret_cast<std::decay<decltype(msg.ESP_APA_GearBoxEnable)>::type*>(&ESP_APA_GearBoxEnable.signal);
        msg.ESP_APA_GearBoxEnable = msg.ESP_APA_GearBoxEnable * factor + offset;
        factor = ABS_ESP_1_EBDFailSts.factor;
        offset = ABS_ESP_1_EBDFailSts.offset;
        msg.ABS_ESP_1_EBDFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_EBDFailSts)>::type*>(&ABS_ESP_1_EBDFailSts.signal);
        msg.ABS_ESP_1_EBDFailSts = msg.ABS_ESP_1_EBDFailSts * factor + offset;
        factor = ESP_APA_Target_Gear_Request.factor;
        offset = ESP_APA_Target_Gear_Request.offset;
        msg.ESP_APA_Target_Gear_Request = *reinterpret_cast<std::decay<decltype(msg.ESP_APA_Target_Gear_Request)>::type*>(&ESP_APA_Target_Gear_Request.signal);
        msg.ESP_APA_Target_Gear_Request = msg.ESP_APA_Target_Gear_Request * factor + offset;
        factor = ABS_ESP_1_ABSFailSts.factor;
        offset = ABS_ESP_1_ABSFailSts.offset;
        msg.ABS_ESP_1_ABSFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_ABSFailSts)>::type*>(&ABS_ESP_1_ABSFailSts.signal);
        msg.ABS_ESP_1_ABSFailSts = msg.ABS_ESP_1_ABSFailSts * factor + offset;
        factor = ABS_ESP_1_ABSActive.factor;
        offset = ABS_ESP_1_ABSActive.offset;
        msg.ABS_ESP_1_ABSActive = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_ABSActive)>::type*>(&ABS_ESP_1_ABSActive.signal);
        msg.ABS_ESP_1_ABSActive = msg.ABS_ESP_1_ABSActive * factor + offset;
        factor = ABS_ESP_1_VDCFailSts.factor;
        offset = ABS_ESP_1_VDCFailSts.offset;
        msg.ABS_ESP_1_VDCFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_VDCFailSts)>::type*>(&ABS_ESP_1_VDCFailSts.signal);
        msg.ABS_ESP_1_VDCFailSts = msg.ABS_ESP_1_VDCFailSts * factor + offset;
        factor = ABS_ESP_1_VDCActive.factor;
        offset = ABS_ESP_1_VDCActive.offset;
        msg.ABS_ESP_1_VDCActive = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_VDCActive)>::type*>(&ABS_ESP_1_VDCActive.signal);
        msg.ABS_ESP_1_VDCActive = msg.ABS_ESP_1_VDCActive * factor + offset;
        factor = ABS_ESP_1_TCSFailSts.factor;
        offset = ABS_ESP_1_TCSFailSts.offset;
        msg.ABS_ESP_1_TCSFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_TCSFailSts)>::type*>(&ABS_ESP_1_TCSFailSts.signal);
        msg.ABS_ESP_1_TCSFailSts = msg.ABS_ESP_1_TCSFailSts * factor + offset;
        factor = ABS_ESP_1_TCSActive.factor;
        offset = ABS_ESP_1_TCSActive.offset;
        msg.ABS_ESP_1_TCSActive = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_TCSActive)>::type*>(&ABS_ESP_1_TCSActive.signal);
        msg.ABS_ESP_1_TCSActive = msg.ABS_ESP_1_TCSActive * factor + offset;
        factor = ABS_ESP_1_PressureMasterCylinder.factor;
        offset = ABS_ESP_1_PressureMasterCylinder.offset;
        msg.ABS_ESP_1_PressureMasterCylinder = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_PressureMasterCylinder)>::type*>(&ABS_ESP_1_PressureMasterCylinder.signal);
        msg.ABS_ESP_1_PressureMasterCylinder = msg.ABS_ESP_1_PressureMasterCylinder * factor + offset;
        factor = ESP1_PressureMasCylindValidData.factor;
        offset = ESP1_PressureMasCylindValidData.offset;
        msg.ESP1_PressureMasCylindValidData = *reinterpret_cast<std::decay<decltype(msg.ESP1_PressureMasCylindValidData)>::type*>(&ESP1_PressureMasCylindValidData.signal);
        msg.ESP1_PressureMasCylindValidData = msg.ESP1_PressureMasCylindValidData * factor + offset;
        factor = IPB_SimulatorPressure.factor;
        offset = IPB_SimulatorPressure.offset;
        msg.IPB_SimulatorPressure = *reinterpret_cast<std::decay<decltype(msg.IPB_SimulatorPressure)>::type*>(&IPB_SimulatorPressure.signal);
        msg.IPB_SimulatorPressure = msg.IPB_SimulatorPressure * factor + offset;
        factor = IPB_SimulatorPressureStatus.factor;
        offset = IPB_SimulatorPressureStatus.offset;
        msg.IPB_SimulatorPressureStatus = *reinterpret_cast<std::decay<decltype(msg.IPB_SimulatorPressureStatus)>::type*>(&IPB_SimulatorPressureStatus.signal);
        msg.IPB_SimulatorPressureStatus = msg.IPB_SimulatorPressureStatus * factor + offset;
        factor = ESP1_VehicleSpeedVSOSigValidData.factor;
        offset = ESP1_VehicleSpeedVSOSigValidData.offset;
        msg.ESP1_VehicleSpeedVSOSigValidData = *reinterpret_cast<std::decay<decltype(msg.ESP1_VehicleSpeedVSOSigValidData)>::type*>(&ESP1_VehicleSpeedVSOSigValidData.signal);
        msg.ESP1_VehicleSpeedVSOSigValidData = msg.ESP1_VehicleSpeedVSOSigValidData * factor + offset;
        factor = ABS_ESP_1_VehicleSpeedVSOSig.factor;
        offset = ABS_ESP_1_VehicleSpeedVSOSig.offset;
        msg.ABS_ESP_1_VehicleSpeedVSOSig = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_VehicleSpeedVSOSig)>::type*>(&ABS_ESP_1_VehicleSpeedVSOSig.signal);
        msg.ABS_ESP_1_VehicleSpeedVSOSig = msg.ABS_ESP_1_VehicleSpeedVSOSig * factor + offset;
        factor = ABS_ESP_1_Checksum.factor;
        offset = ABS_ESP_1_Checksum.offset;
        msg.ABS_ESP_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_Checksum)>::type*>(&ABS_ESP_1_Checksum.signal);
        msg.ABS_ESP_1_Checksum = msg.ABS_ESP_1_Checksum * factor + offset;
        factor = ABS_ESP_1_HDCCtrlSts.factor;
        offset = ABS_ESP_1_HDCCtrlSts.offset;
        msg.ABS_ESP_1_HDCCtrlSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_HDCCtrlSts)>::type*>(&ABS_ESP_1_HDCCtrlSts.signal);
        msg.ABS_ESP_1_HDCCtrlSts = msg.ABS_ESP_1_HDCCtrlSts * factor + offset;
        factor = ABS_ESP_1_HDCFailSts.factor;
        offset = ABS_ESP_1_HDCFailSts.offset;
        msg.ABS_ESP_1_HDCFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_HDCFailSts)>::type*>(&ABS_ESP_1_HDCFailSts.signal);
        msg.ABS_ESP_1_HDCFailSts = msg.ABS_ESP_1_HDCFailSts * factor + offset;
        factor = ABS_ESP_1_MessageCounter.factor;
        offset = ABS_ESP_1_MessageCounter.offset;
        msg.ABS_ESP_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_MessageCounter)>::type*>(&ABS_ESP_1_MessageCounter.signal);
        msg.ABS_ESP_1_MessageCounter = msg.ABS_ESP_1_MessageCounter * factor + offset;
        factor = ABS_ESP_1_ESPSwitchStatus.factor;
        offset = ABS_ESP_1_ESPSwitchStatus.offset;
        msg.ABS_ESP_1_ESPSwitchStatus = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_1_ESPSwitchStatus)>::type*>(&ABS_ESP_1_ESPSwitchStatus.signal);
        msg.ABS_ESP_1_ESPSwitchStatus = msg.ABS_ESP_1_ESPSwitchStatus * factor + offset;
        factor = SwitchOffCruiseControl.factor;
        offset = SwitchOffCruiseControl.offset;
        msg.SwitchOffCruiseControl = *reinterpret_cast<std::decay<decltype(msg.SwitchOffCruiseControl)>::type*>(&SwitchOffCruiseControl.signal);
        msg.SwitchOffCruiseControl = msg.SwitchOffCruiseControl * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_1_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_1_MSGMsg>();
        Struct2Proto_ABS_ESP_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_1") != nullptr) {
            DFHLOG_I("abs_esp_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_1");
            return false;
         }
    }
};

struct ABS_ESP_3_Parser {
    SignalParser NoBrakeForce;

    SignalParser ABS_ESP_3_AVHFailSts;

    SignalParser ESP_VLCEngTorqReq;

    SignalParser ABS_ESP_3_AVHSts;

    SignalParser ESP_VLCEngTorqReqValidData;

    SignalParser ABS_ESP_3_MessageCounter;

    SignalParser ABS_ESP_3_Checksum;

    ABS_ESP_3_Parser() {
        NoBrakeForce = CanConfiguration::Instance().SignalParsers()["NoBrakeForce"];
        ABS_ESP_3_AVHFailSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_3_AVHFailSts"];
        ESP_VLCEngTorqReq = CanConfiguration::Instance().SignalParsers()["ESP_VLCEngTorqReq"];
        ABS_ESP_3_AVHSts = CanConfiguration::Instance().SignalParsers()["ABS_ESP_3_AVHSts"];
        ESP_VLCEngTorqReqValidData = CanConfiguration::Instance().SignalParsers()["ESP_VLCEngTorqReqValidData"];
        ABS_ESP_3_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABS_ESP_3_MessageCounter"];
        ABS_ESP_3_Checksum = CanConfiguration::Instance().SignalParsers()["ABS_ESP_3_Checksum"];
    }

    void Parser(uint8_t* payload){
        NoBrakeForce.Parser(payload);
        ABS_ESP_3_AVHFailSts.Parser(payload);
        ESP_VLCEngTorqReq.Parser(payload);
        ABS_ESP_3_AVHSts.Parser(payload);
        ESP_VLCEngTorqReqValidData.Parser(payload);
        ABS_ESP_3_MessageCounter.Parser(payload);
        ABS_ESP_3_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_3_MSG(ABS_ESP_3_MSG& msg) {
        double factor;
        double offset;
        factor = NoBrakeForce.factor;
        offset = NoBrakeForce.offset;
        msg.NoBrakeForce = *reinterpret_cast<std::decay<decltype(msg.NoBrakeForce)>::type*>(&NoBrakeForce.signal);
        msg.NoBrakeForce = msg.NoBrakeForce * factor + offset;
        factor = ABS_ESP_3_AVHFailSts.factor;
        offset = ABS_ESP_3_AVHFailSts.offset;
        msg.ABS_ESP_3_AVHFailSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_3_AVHFailSts)>::type*>(&ABS_ESP_3_AVHFailSts.signal);
        msg.ABS_ESP_3_AVHFailSts = msg.ABS_ESP_3_AVHFailSts * factor + offset;
        factor = ESP_VLCEngTorqReq.factor;
        offset = ESP_VLCEngTorqReq.offset;
        msg.ESP_VLCEngTorqReq = *reinterpret_cast<std::decay<decltype(msg.ESP_VLCEngTorqReq)>::type*>(&ESP_VLCEngTorqReq.signal);
        msg.ESP_VLCEngTorqReq = msg.ESP_VLCEngTorqReq * factor + offset;
        factor = ABS_ESP_3_AVHSts.factor;
        offset = ABS_ESP_3_AVHSts.offset;
        msg.ABS_ESP_3_AVHSts = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_3_AVHSts)>::type*>(&ABS_ESP_3_AVHSts.signal);
        msg.ABS_ESP_3_AVHSts = msg.ABS_ESP_3_AVHSts * factor + offset;
        factor = ESP_VLCEngTorqReqValidData.factor;
        offset = ESP_VLCEngTorqReqValidData.offset;
        msg.ESP_VLCEngTorqReqValidData = *reinterpret_cast<std::decay<decltype(msg.ESP_VLCEngTorqReqValidData)>::type*>(&ESP_VLCEngTorqReqValidData.signal);
        msg.ESP_VLCEngTorqReqValidData = msg.ESP_VLCEngTorqReqValidData * factor + offset;
        factor = ABS_ESP_3_MessageCounter.factor;
        offset = ABS_ESP_3_MessageCounter.offset;
        msg.ABS_ESP_3_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_3_MessageCounter)>::type*>(&ABS_ESP_3_MessageCounter.signal);
        msg.ABS_ESP_3_MessageCounter = msg.ABS_ESP_3_MessageCounter * factor + offset;
        factor = ABS_ESP_3_Checksum.factor;
        offset = ABS_ESP_3_Checksum.offset;
        msg.ABS_ESP_3_Checksum = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_3_Checksum)>::type*>(&ABS_ESP_3_Checksum.signal);
        msg.ABS_ESP_3_Checksum = msg.ABS_ESP_3_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_3_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_3_MSGMsg>();
        Struct2Proto_ABS_ESP_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_3") != nullptr) {
            DFHLOG_I("abs_esp_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_3");
            return false;
         }
    }
};

struct ABS_ESP_4_Parser {
    SignalParser VLC_InternalTargetAcceleration;

    SignalParser VehicleStandstill;

    SignalParser AWBactive;

    SignalParser AWBavailable;

    SignalParser ECDTempOff;

    SignalParser DCFail;

    SignalParser VLC_Active;

    SignalParser VLC_Available;

    SignalParser CDDActive;

    SignalParser CDDAvailable;

    SignalParser ABAactive;

    SignalParser ABAavailable;

    SignalParser ABS_ESP_4_MessageCounter;

    SignalParser ABS_ESP_4_Checksum;

    ABS_ESP_4_Parser() {
        VLC_InternalTargetAcceleration = CanConfiguration::Instance().SignalParsers()["VLC_InternalTargetAcceleration"];
        VehicleStandstill = CanConfiguration::Instance().SignalParsers()["VehicleStandstill"];
        AWBactive = CanConfiguration::Instance().SignalParsers()["AWBactive"];
        AWBavailable = CanConfiguration::Instance().SignalParsers()["AWBavailable"];
        ECDTempOff = CanConfiguration::Instance().SignalParsers()["ECDTempOff"];
        DCFail = CanConfiguration::Instance().SignalParsers()["DCFail"];
        VLC_Active = CanConfiguration::Instance().SignalParsers()["VLC_Active"];
        VLC_Available = CanConfiguration::Instance().SignalParsers()["VLC_Available"];
        CDDActive = CanConfiguration::Instance().SignalParsers()["CDDActive"];
        CDDAvailable = CanConfiguration::Instance().SignalParsers()["CDDAvailable"];
        ABAactive = CanConfiguration::Instance().SignalParsers()["ABAactive"];
        ABAavailable = CanConfiguration::Instance().SignalParsers()["ABAavailable"];
        ABS_ESP_4_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABS_ESP_4_MessageCounter"];
        ABS_ESP_4_Checksum = CanConfiguration::Instance().SignalParsers()["ABS_ESP_4_Checksum"];
    }

    void Parser(uint8_t* payload){
        VLC_InternalTargetAcceleration.Parser(payload);
        VehicleStandstill.Parser(payload);
        AWBactive.Parser(payload);
        AWBavailable.Parser(payload);
        ECDTempOff.Parser(payload);
        DCFail.Parser(payload);
        VLC_Active.Parser(payload);
        VLC_Available.Parser(payload);
        CDDActive.Parser(payload);
        CDDAvailable.Parser(payload);
        ABAactive.Parser(payload);
        ABAavailable.Parser(payload);
        ABS_ESP_4_MessageCounter.Parser(payload);
        ABS_ESP_4_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_4_MSG(ABS_ESP_4_MSG& msg) {
        double factor;
        double offset;
        factor = VLC_InternalTargetAcceleration.factor;
        offset = VLC_InternalTargetAcceleration.offset;
        msg.VLC_InternalTargetAcceleration = *reinterpret_cast<std::decay<decltype(msg.VLC_InternalTargetAcceleration)>::type*>(&VLC_InternalTargetAcceleration.signal);
        msg.VLC_InternalTargetAcceleration = msg.VLC_InternalTargetAcceleration * factor + offset;
        factor = VehicleStandstill.factor;
        offset = VehicleStandstill.offset;
        msg.VehicleStandstill = *reinterpret_cast<std::decay<decltype(msg.VehicleStandstill)>::type*>(&VehicleStandstill.signal);
        msg.VehicleStandstill = msg.VehicleStandstill * factor + offset;
        factor = AWBactive.factor;
        offset = AWBactive.offset;
        msg.AWBactive = *reinterpret_cast<std::decay<decltype(msg.AWBactive)>::type*>(&AWBactive.signal);
        msg.AWBactive = msg.AWBactive * factor + offset;
        factor = AWBavailable.factor;
        offset = AWBavailable.offset;
        msg.AWBavailable = *reinterpret_cast<std::decay<decltype(msg.AWBavailable)>::type*>(&AWBavailable.signal);
        msg.AWBavailable = msg.AWBavailable * factor + offset;
        factor = ECDTempOff.factor;
        offset = ECDTempOff.offset;
        msg.ECDTempOff = *reinterpret_cast<std::decay<decltype(msg.ECDTempOff)>::type*>(&ECDTempOff.signal);
        msg.ECDTempOff = msg.ECDTempOff * factor + offset;
        factor = DCFail.factor;
        offset = DCFail.offset;
        msg.DCFail = *reinterpret_cast<std::decay<decltype(msg.DCFail)>::type*>(&DCFail.signal);
        msg.DCFail = msg.DCFail * factor + offset;
        factor = VLC_Active.factor;
        offset = VLC_Active.offset;
        msg.VLC_Active = *reinterpret_cast<std::decay<decltype(msg.VLC_Active)>::type*>(&VLC_Active.signal);
        msg.VLC_Active = msg.VLC_Active * factor + offset;
        factor = VLC_Available.factor;
        offset = VLC_Available.offset;
        msg.VLC_Available = *reinterpret_cast<std::decay<decltype(msg.VLC_Available)>::type*>(&VLC_Available.signal);
        msg.VLC_Available = msg.VLC_Available * factor + offset;
        factor = CDDActive.factor;
        offset = CDDActive.offset;
        msg.CDDActive = *reinterpret_cast<std::decay<decltype(msg.CDDActive)>::type*>(&CDDActive.signal);
        msg.CDDActive = msg.CDDActive * factor + offset;
        factor = CDDAvailable.factor;
        offset = CDDAvailable.offset;
        msg.CDDAvailable = *reinterpret_cast<std::decay<decltype(msg.CDDAvailable)>::type*>(&CDDAvailable.signal);
        msg.CDDAvailable = msg.CDDAvailable * factor + offset;
        factor = ABAactive.factor;
        offset = ABAactive.offset;
        msg.ABAactive = *reinterpret_cast<std::decay<decltype(msg.ABAactive)>::type*>(&ABAactive.signal);
        msg.ABAactive = msg.ABAactive * factor + offset;
        factor = ABAavailable.factor;
        offset = ABAavailable.offset;
        msg.ABAavailable = *reinterpret_cast<std::decay<decltype(msg.ABAavailable)>::type*>(&ABAavailable.signal);
        msg.ABAavailable = msg.ABAavailable * factor + offset;
        factor = ABS_ESP_4_MessageCounter.factor;
        offset = ABS_ESP_4_MessageCounter.offset;
        msg.ABS_ESP_4_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_4_MessageCounter)>::type*>(&ABS_ESP_4_MessageCounter.signal);
        msg.ABS_ESP_4_MessageCounter = msg.ABS_ESP_4_MessageCounter * factor + offset;
        factor = ABS_ESP_4_Checksum.factor;
        offset = ABS_ESP_4_Checksum.offset;
        msg.ABS_ESP_4_Checksum = *reinterpret_cast<std::decay<decltype(msg.ABS_ESP_4_Checksum)>::type*>(&ABS_ESP_4_Checksum.signal);
        msg.ABS_ESP_4_Checksum = msg.ABS_ESP_4_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_4_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_4_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_4_MSGMsg>();
        Struct2Proto_ABS_ESP_4_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_4") != nullptr) {
            DFHLOG_I("abs_esp_4");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_4")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_4");
            return false;
         }
    }
};

struct ABS_ESP_5_Parser {
    SignalParser LHRPulseCounter;

    SignalParser LHRPulseCounterFailSts;

    SignalParser RHFPulseCounterFailSts;

    SignalParser LHFPulseCounterFailSts;

    SignalParser RHRPulseCounter;

    SignalParser RHRPulseCounterFailSts;

    SignalParser RHFPulseCounter;

    SignalParser LHFPulseCounter;

    ABS_ESP_5_Parser() {
        LHRPulseCounter = CanConfiguration::Instance().SignalParsers()["LHRPulseCounter"];
        LHRPulseCounterFailSts = CanConfiguration::Instance().SignalParsers()["LHRPulseCounterFailSts"];
        RHFPulseCounterFailSts = CanConfiguration::Instance().SignalParsers()["RHFPulseCounterFailSts"];
        LHFPulseCounterFailSts = CanConfiguration::Instance().SignalParsers()["LHFPulseCounterFailSts"];
        RHRPulseCounter = CanConfiguration::Instance().SignalParsers()["RHRPulseCounter"];
        RHRPulseCounterFailSts = CanConfiguration::Instance().SignalParsers()["RHRPulseCounterFailSts"];
        RHFPulseCounter = CanConfiguration::Instance().SignalParsers()["RHFPulseCounter"];
        LHFPulseCounter = CanConfiguration::Instance().SignalParsers()["LHFPulseCounter"];
    }

    void Parser(uint8_t* payload){
        LHRPulseCounter.Parser(payload);
        LHRPulseCounterFailSts.Parser(payload);
        RHFPulseCounterFailSts.Parser(payload);
        LHFPulseCounterFailSts.Parser(payload);
        RHRPulseCounter.Parser(payload);
        RHRPulseCounterFailSts.Parser(payload);
        RHFPulseCounter.Parser(payload);
        LHFPulseCounter.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_5_MSG(ABS_ESP_5_MSG& msg) {
        double factor;
        double offset;
        factor = LHRPulseCounter.factor;
        offset = LHRPulseCounter.offset;
        msg.LHRPulseCounter = *reinterpret_cast<std::decay<decltype(msg.LHRPulseCounter)>::type*>(&LHRPulseCounter.signal);
        msg.LHRPulseCounter = msg.LHRPulseCounter * factor + offset;
        factor = LHRPulseCounterFailSts.factor;
        offset = LHRPulseCounterFailSts.offset;
        msg.LHRPulseCounterFailSts = *reinterpret_cast<std::decay<decltype(msg.LHRPulseCounterFailSts)>::type*>(&LHRPulseCounterFailSts.signal);
        msg.LHRPulseCounterFailSts = msg.LHRPulseCounterFailSts * factor + offset;
        factor = RHFPulseCounterFailSts.factor;
        offset = RHFPulseCounterFailSts.offset;
        msg.RHFPulseCounterFailSts = *reinterpret_cast<std::decay<decltype(msg.RHFPulseCounterFailSts)>::type*>(&RHFPulseCounterFailSts.signal);
        msg.RHFPulseCounterFailSts = msg.RHFPulseCounterFailSts * factor + offset;
        factor = LHFPulseCounterFailSts.factor;
        offset = LHFPulseCounterFailSts.offset;
        msg.LHFPulseCounterFailSts = *reinterpret_cast<std::decay<decltype(msg.LHFPulseCounterFailSts)>::type*>(&LHFPulseCounterFailSts.signal);
        msg.LHFPulseCounterFailSts = msg.LHFPulseCounterFailSts * factor + offset;
        factor = RHRPulseCounter.factor;
        offset = RHRPulseCounter.offset;
        msg.RHRPulseCounter = *reinterpret_cast<std::decay<decltype(msg.RHRPulseCounter)>::type*>(&RHRPulseCounter.signal);
        msg.RHRPulseCounter = msg.RHRPulseCounter * factor + offset;
        factor = RHRPulseCounterFailSts.factor;
        offset = RHRPulseCounterFailSts.offset;
        msg.RHRPulseCounterFailSts = *reinterpret_cast<std::decay<decltype(msg.RHRPulseCounterFailSts)>::type*>(&RHRPulseCounterFailSts.signal);
        msg.RHRPulseCounterFailSts = msg.RHRPulseCounterFailSts * factor + offset;
        factor = RHFPulseCounter.factor;
        offset = RHFPulseCounter.offset;
        msg.RHFPulseCounter = *reinterpret_cast<std::decay<decltype(msg.RHFPulseCounter)>::type*>(&RHFPulseCounter.signal);
        msg.RHFPulseCounter = msg.RHFPulseCounter * factor + offset;
        factor = LHFPulseCounter.factor;
        offset = LHFPulseCounter.offset;
        msg.LHFPulseCounter = *reinterpret_cast<std::decay<decltype(msg.LHFPulseCounter)>::type*>(&LHFPulseCounter.signal);
        msg.LHFPulseCounter = msg.LHFPulseCounter * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_5_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_5_MSGMsg>();
        Struct2Proto_ABS_ESP_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_5") != nullptr) {
            DFHLOG_I("abs_esp_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_5");
            return false;
         }
    }
};

struct ABS_ESP_7_Parser {
    SignalParser LHFWheelSpeedRaw;

    SignalParser LHFWheelDriveDirection;

    SignalParser LHFWheelSpeedRawValidData;

    SignalParser RHFWheelSpeedRaw;

    SignalParser RHFWheelDriveDirection;

    SignalParser RHFWheelSpeedRawValidData;

    SignalParser QDCACC;

    SignalParser VLCFail;

    SignalParser WheelBrakeForce;

    SignalParser ABSESP_7_MessageCounter;

    SignalParser ABSESP_7_Checksum;

    ABS_ESP_7_Parser() {
        LHFWheelSpeedRaw = CanConfiguration::Instance().SignalParsers()["LHFWheelSpeedRaw"];
        LHFWheelDriveDirection = CanConfiguration::Instance().SignalParsers()["LHFWheelDriveDirection"];
        LHFWheelSpeedRawValidData = CanConfiguration::Instance().SignalParsers()["LHFWheelSpeedRawValidData"];
        RHFWheelSpeedRaw = CanConfiguration::Instance().SignalParsers()["RHFWheelSpeedRaw"];
        RHFWheelDriveDirection = CanConfiguration::Instance().SignalParsers()["RHFWheelDriveDirection"];
        RHFWheelSpeedRawValidData = CanConfiguration::Instance().SignalParsers()["RHFWheelSpeedRawValidData"];
        QDCACC = CanConfiguration::Instance().SignalParsers()["QDCACC"];
        VLCFail = CanConfiguration::Instance().SignalParsers()["VLCFail"];
        WheelBrakeForce = CanConfiguration::Instance().SignalParsers()["WheelBrakeForce"];
        ABSESP_7_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABSESP_7_MessageCounter"];
        ABSESP_7_Checksum = CanConfiguration::Instance().SignalParsers()["ABSESP_7_Checksum"];
    }

    void Parser(uint8_t* payload){
        LHFWheelSpeedRaw.Parser(payload);
        LHFWheelDriveDirection.Parser(payload);
        LHFWheelSpeedRawValidData.Parser(payload);
        RHFWheelSpeedRaw.Parser(payload);
        RHFWheelDriveDirection.Parser(payload);
        RHFWheelSpeedRawValidData.Parser(payload);
        QDCACC.Parser(payload);
        VLCFail.Parser(payload);
        WheelBrakeForce.Parser(payload);
        ABSESP_7_MessageCounter.Parser(payload);
        ABSESP_7_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_7_MSG(ABS_ESP_7_MSG& msg) {
        double factor;
        double offset;
        factor = LHFWheelSpeedRaw.factor;
        offset = LHFWheelSpeedRaw.offset;
        msg.LHFWheelSpeedRaw = *reinterpret_cast<std::decay<decltype(msg.LHFWheelSpeedRaw)>::type*>(&LHFWheelSpeedRaw.signal);
        msg.LHFWheelSpeedRaw = msg.LHFWheelSpeedRaw * factor + offset;
        factor = LHFWheelDriveDirection.factor;
        offset = LHFWheelDriveDirection.offset;
        msg.LHFWheelDriveDirection = *reinterpret_cast<std::decay<decltype(msg.LHFWheelDriveDirection)>::type*>(&LHFWheelDriveDirection.signal);
        msg.LHFWheelDriveDirection = msg.LHFWheelDriveDirection * factor + offset;
        factor = LHFWheelSpeedRawValidData.factor;
        offset = LHFWheelSpeedRawValidData.offset;
        msg.LHFWheelSpeedRawValidData = *reinterpret_cast<std::decay<decltype(msg.LHFWheelSpeedRawValidData)>::type*>(&LHFWheelSpeedRawValidData.signal);
        msg.LHFWheelSpeedRawValidData = msg.LHFWheelSpeedRawValidData * factor + offset;
        factor = RHFWheelSpeedRaw.factor;
        offset = RHFWheelSpeedRaw.offset;
        msg.RHFWheelSpeedRaw = *reinterpret_cast<std::decay<decltype(msg.RHFWheelSpeedRaw)>::type*>(&RHFWheelSpeedRaw.signal);
        msg.RHFWheelSpeedRaw = msg.RHFWheelSpeedRaw * factor + offset;
        factor = RHFWheelDriveDirection.factor;
        offset = RHFWheelDriveDirection.offset;
        msg.RHFWheelDriveDirection = *reinterpret_cast<std::decay<decltype(msg.RHFWheelDriveDirection)>::type*>(&RHFWheelDriveDirection.signal);
        msg.RHFWheelDriveDirection = msg.RHFWheelDriveDirection * factor + offset;
        factor = RHFWheelSpeedRawValidData.factor;
        offset = RHFWheelSpeedRawValidData.offset;
        msg.RHFWheelSpeedRawValidData = *reinterpret_cast<std::decay<decltype(msg.RHFWheelSpeedRawValidData)>::type*>(&RHFWheelSpeedRawValidData.signal);
        msg.RHFWheelSpeedRawValidData = msg.RHFWheelSpeedRawValidData * factor + offset;
        factor = QDCACC.factor;
        offset = QDCACC.offset;
        msg.QDCACC = *reinterpret_cast<std::decay<decltype(msg.QDCACC)>::type*>(&QDCACC.signal);
        msg.QDCACC = msg.QDCACC * factor + offset;
        factor = VLCFail.factor;
        offset = VLCFail.offset;
        msg.VLCFail = *reinterpret_cast<std::decay<decltype(msg.VLCFail)>::type*>(&VLCFail.signal);
        msg.VLCFail = msg.VLCFail * factor + offset;
        factor = WheelBrakeForce.factor;
        offset = WheelBrakeForce.offset;
        msg.WheelBrakeForce = *reinterpret_cast<std::decay<decltype(msg.WheelBrakeForce)>::type*>(&WheelBrakeForce.signal);
        msg.WheelBrakeForce = msg.WheelBrakeForce * factor + offset;
        factor = ABSESP_7_MessageCounter.factor;
        offset = ABSESP_7_MessageCounter.offset;
        msg.ABSESP_7_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABSESP_7_MessageCounter)>::type*>(&ABSESP_7_MessageCounter.signal);
        msg.ABSESP_7_MessageCounter = msg.ABSESP_7_MessageCounter * factor + offset;
        factor = ABSESP_7_Checksum.factor;
        offset = ABSESP_7_Checksum.offset;
        msg.ABSESP_7_Checksum = *reinterpret_cast<std::decay<decltype(msg.ABSESP_7_Checksum)>::type*>(&ABSESP_7_Checksum.signal);
        msg.ABSESP_7_Checksum = msg.ABSESP_7_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_7_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_7_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_7_MSGMsg>();
        Struct2Proto_ABS_ESP_7_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_7") != nullptr) {
            DFHLOG_I("abs_esp_7");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_7")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_7");
            return false;
         }
    }
};

struct ABS_ESP_8_Parser {
    SignalParser LHRWheelSpeedRaw;

    SignalParser LHRWheelDriveDirection;

    SignalParser LHRWheelSpeedRawValidData;

    SignalParser RHRWheelSpeedRaw;

    SignalParser RHRWheelDriveDirection;

    SignalParser RHRWheelSpeedRawValidData;

    SignalParser ABPActive;

    SignalParser ABPAvailable;

    SignalParser AEBdecActive;

    SignalParser AEBdecAvailable;

    SignalParser ABSESP_8_RCTBAvl;

    SignalParser ABSESP_8_CDDActvVehAutoHld;

    SignalParser ABSESP_8_RAEBdecActv;

    SignalParser ABSESP_8_RAEBAvl;

    SignalParser ABSESP_8_RCTBdecActv;

    SignalParser ESP_APA_LC_Status;

    SignalParser ESP_APA_LC_FailureSts;

    SignalParser ESC_APA_LC_Availability;

    SignalParser ABSESP_8_MessageCounter;

    SignalParser ABSESP_8_Checksum;

    ABS_ESP_8_Parser() {
        LHRWheelSpeedRaw = CanConfiguration::Instance().SignalParsers()["LHRWheelSpeedRaw"];
        LHRWheelDriveDirection = CanConfiguration::Instance().SignalParsers()["LHRWheelDriveDirection"];
        LHRWheelSpeedRawValidData = CanConfiguration::Instance().SignalParsers()["LHRWheelSpeedRawValidData"];
        RHRWheelSpeedRaw = CanConfiguration::Instance().SignalParsers()["RHRWheelSpeedRaw"];
        RHRWheelDriveDirection = CanConfiguration::Instance().SignalParsers()["RHRWheelDriveDirection"];
        RHRWheelSpeedRawValidData = CanConfiguration::Instance().SignalParsers()["RHRWheelSpeedRawValidData"];
        ABPActive = CanConfiguration::Instance().SignalParsers()["ABPActive"];
        ABPAvailable = CanConfiguration::Instance().SignalParsers()["ABPAvailable"];
        AEBdecActive = CanConfiguration::Instance().SignalParsers()["AEBdecActive"];
        AEBdecAvailable = CanConfiguration::Instance().SignalParsers()["AEBdecAvailable"];
        ABSESP_8_RCTBAvl = CanConfiguration::Instance().SignalParsers()["ABSESP_8_RCTBAvl"];
        ABSESP_8_CDDActvVehAutoHld = CanConfiguration::Instance().SignalParsers()["ABSESP_8_CDDActvVehAutoHld"];
        ABSESP_8_RAEBdecActv = CanConfiguration::Instance().SignalParsers()["ABSESP_8_RAEBdecActv"];
        ABSESP_8_RAEBAvl = CanConfiguration::Instance().SignalParsers()["ABSESP_8_RAEBAvl"];
        ABSESP_8_RCTBdecActv = CanConfiguration::Instance().SignalParsers()["ABSESP_8_RCTBdecActv"];
        ESP_APA_LC_Status = CanConfiguration::Instance().SignalParsers()["ESP_APA_LC_Status"];
        ESP_APA_LC_FailureSts = CanConfiguration::Instance().SignalParsers()["ESP_APA_LC_FailureSts"];
        ESC_APA_LC_Availability = CanConfiguration::Instance().SignalParsers()["ESC_APA_LC_Availability"];
        ABSESP_8_MessageCounter = CanConfiguration::Instance().SignalParsers()["ABSESP_8_MessageCounter"];
        ABSESP_8_Checksum = CanConfiguration::Instance().SignalParsers()["ABSESP_8_Checksum"];
    }

    void Parser(uint8_t* payload){
        LHRWheelSpeedRaw.Parser(payload);
        LHRWheelDriveDirection.Parser(payload);
        LHRWheelSpeedRawValidData.Parser(payload);
        RHRWheelSpeedRaw.Parser(payload);
        RHRWheelDriveDirection.Parser(payload);
        RHRWheelSpeedRawValidData.Parser(payload);
        ABPActive.Parser(payload);
        ABPAvailable.Parser(payload);
        AEBdecActive.Parser(payload);
        AEBdecAvailable.Parser(payload);
        ABSESP_8_RCTBAvl.Parser(payload);
        ABSESP_8_CDDActvVehAutoHld.Parser(payload);
        ABSESP_8_RAEBdecActv.Parser(payload);
        ABSESP_8_RAEBAvl.Parser(payload);
        ABSESP_8_RCTBdecActv.Parser(payload);
        ESP_APA_LC_Status.Parser(payload);
        ESP_APA_LC_FailureSts.Parser(payload);
        ESC_APA_LC_Availability.Parser(payload);
        ABSESP_8_MessageCounter.Parser(payload);
        ABSESP_8_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_8_MSG(ABS_ESP_8_MSG& msg) {
        double factor;
        double offset;
        factor = LHRWheelSpeedRaw.factor;
        offset = LHRWheelSpeedRaw.offset;
        msg.LHRWheelSpeedRaw = *reinterpret_cast<std::decay<decltype(msg.LHRWheelSpeedRaw)>::type*>(&LHRWheelSpeedRaw.signal);
        msg.LHRWheelSpeedRaw = msg.LHRWheelSpeedRaw * factor + offset;
        factor = LHRWheelDriveDirection.factor;
        offset = LHRWheelDriveDirection.offset;
        msg.LHRWheelDriveDirection = *reinterpret_cast<std::decay<decltype(msg.LHRWheelDriveDirection)>::type*>(&LHRWheelDriveDirection.signal);
        msg.LHRWheelDriveDirection = msg.LHRWheelDriveDirection * factor + offset;
        factor = LHRWheelSpeedRawValidData.factor;
        offset = LHRWheelSpeedRawValidData.offset;
        msg.LHRWheelSpeedRawValidData = *reinterpret_cast<std::decay<decltype(msg.LHRWheelSpeedRawValidData)>::type*>(&LHRWheelSpeedRawValidData.signal);
        msg.LHRWheelSpeedRawValidData = msg.LHRWheelSpeedRawValidData * factor + offset;
        factor = RHRWheelSpeedRaw.factor;
        offset = RHRWheelSpeedRaw.offset;
        msg.RHRWheelSpeedRaw = *reinterpret_cast<std::decay<decltype(msg.RHRWheelSpeedRaw)>::type*>(&RHRWheelSpeedRaw.signal);
        msg.RHRWheelSpeedRaw = msg.RHRWheelSpeedRaw * factor + offset;
        factor = RHRWheelDriveDirection.factor;
        offset = RHRWheelDriveDirection.offset;
        msg.RHRWheelDriveDirection = *reinterpret_cast<std::decay<decltype(msg.RHRWheelDriveDirection)>::type*>(&RHRWheelDriveDirection.signal);
        msg.RHRWheelDriveDirection = msg.RHRWheelDriveDirection * factor + offset;
        factor = RHRWheelSpeedRawValidData.factor;
        offset = RHRWheelSpeedRawValidData.offset;
        msg.RHRWheelSpeedRawValidData = *reinterpret_cast<std::decay<decltype(msg.RHRWheelSpeedRawValidData)>::type*>(&RHRWheelSpeedRawValidData.signal);
        msg.RHRWheelSpeedRawValidData = msg.RHRWheelSpeedRawValidData * factor + offset;
        factor = ABPActive.factor;
        offset = ABPActive.offset;
        msg.ABPActive = *reinterpret_cast<std::decay<decltype(msg.ABPActive)>::type*>(&ABPActive.signal);
        msg.ABPActive = msg.ABPActive * factor + offset;
        factor = ABPAvailable.factor;
        offset = ABPAvailable.offset;
        msg.ABPAvailable = *reinterpret_cast<std::decay<decltype(msg.ABPAvailable)>::type*>(&ABPAvailable.signal);
        msg.ABPAvailable = msg.ABPAvailable * factor + offset;
        factor = AEBdecActive.factor;
        offset = AEBdecActive.offset;
        msg.AEBdecActive = *reinterpret_cast<std::decay<decltype(msg.AEBdecActive)>::type*>(&AEBdecActive.signal);
        msg.AEBdecActive = msg.AEBdecActive * factor + offset;
        factor = AEBdecAvailable.factor;
        offset = AEBdecAvailable.offset;
        msg.AEBdecAvailable = *reinterpret_cast<std::decay<decltype(msg.AEBdecAvailable)>::type*>(&AEBdecAvailable.signal);
        msg.AEBdecAvailable = msg.AEBdecAvailable * factor + offset;
        factor = ABSESP_8_RCTBAvl.factor;
        offset = ABSESP_8_RCTBAvl.offset;
        msg.ABSESP_8_RCTBAvl = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_RCTBAvl)>::type*>(&ABSESP_8_RCTBAvl.signal);
        msg.ABSESP_8_RCTBAvl = msg.ABSESP_8_RCTBAvl * factor + offset;
        factor = ABSESP_8_CDDActvVehAutoHld.factor;
        offset = ABSESP_8_CDDActvVehAutoHld.offset;
        msg.ABSESP_8_CDDActvVehAutoHld = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_CDDActvVehAutoHld)>::type*>(&ABSESP_8_CDDActvVehAutoHld.signal);
        msg.ABSESP_8_CDDActvVehAutoHld = msg.ABSESP_8_CDDActvVehAutoHld * factor + offset;
        factor = ABSESP_8_RAEBdecActv.factor;
        offset = ABSESP_8_RAEBdecActv.offset;
        msg.ABSESP_8_RAEBdecActv = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_RAEBdecActv)>::type*>(&ABSESP_8_RAEBdecActv.signal);
        msg.ABSESP_8_RAEBdecActv = msg.ABSESP_8_RAEBdecActv * factor + offset;
        factor = ABSESP_8_RAEBAvl.factor;
        offset = ABSESP_8_RAEBAvl.offset;
        msg.ABSESP_8_RAEBAvl = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_RAEBAvl)>::type*>(&ABSESP_8_RAEBAvl.signal);
        msg.ABSESP_8_RAEBAvl = msg.ABSESP_8_RAEBAvl * factor + offset;
        factor = ABSESP_8_RCTBdecActv.factor;
        offset = ABSESP_8_RCTBdecActv.offset;
        msg.ABSESP_8_RCTBdecActv = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_RCTBdecActv)>::type*>(&ABSESP_8_RCTBdecActv.signal);
        msg.ABSESP_8_RCTBdecActv = msg.ABSESP_8_RCTBdecActv * factor + offset;
        factor = ESP_APA_LC_Status.factor;
        offset = ESP_APA_LC_Status.offset;
        msg.ESP_APA_LC_Status = *reinterpret_cast<std::decay<decltype(msg.ESP_APA_LC_Status)>::type*>(&ESP_APA_LC_Status.signal);
        msg.ESP_APA_LC_Status = msg.ESP_APA_LC_Status * factor + offset;
        factor = ESP_APA_LC_FailureSts.factor;
        offset = ESP_APA_LC_FailureSts.offset;
        msg.ESP_APA_LC_FailureSts = *reinterpret_cast<std::decay<decltype(msg.ESP_APA_LC_FailureSts)>::type*>(&ESP_APA_LC_FailureSts.signal);
        msg.ESP_APA_LC_FailureSts = msg.ESP_APA_LC_FailureSts * factor + offset;
        factor = ESC_APA_LC_Availability.factor;
        offset = ESC_APA_LC_Availability.offset;
        msg.ESC_APA_LC_Availability = *reinterpret_cast<std::decay<decltype(msg.ESC_APA_LC_Availability)>::type*>(&ESC_APA_LC_Availability.signal);
        msg.ESC_APA_LC_Availability = msg.ESC_APA_LC_Availability * factor + offset;
        factor = ABSESP_8_MessageCounter.factor;
        offset = ABSESP_8_MessageCounter.offset;
        msg.ABSESP_8_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_MessageCounter)>::type*>(&ABSESP_8_MessageCounter.signal);
        msg.ABSESP_8_MessageCounter = msg.ABSESP_8_MessageCounter * factor + offset;
        factor = ABSESP_8_Checksum.factor;
        offset = ABSESP_8_Checksum.offset;
        msg.ABSESP_8_Checksum = *reinterpret_cast<std::decay<decltype(msg.ABSESP_8_Checksum)>::type*>(&ABSESP_8_Checksum.signal);
        msg.ABSESP_8_Checksum = msg.ABSESP_8_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_8_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_8_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_8_MSGMsg>();
        Struct2Proto_ABS_ESP_8_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_8") != nullptr) {
            DFHLOG_I("abs_esp_8");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_8")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_8");
            return false;
         }
    }
};

struct ABS_ESP_G_Parser {
    SignalParser CDPActive;

    ABS_ESP_G_Parser() {
        CDPActive = CanConfiguration::Instance().SignalParsers()["CDPActive"];
    }

    void Parser(uint8_t* payload){
        CDPActive.Parser(payload);
    }

    void CanParser2CanStruct_ABS_ESP_G_MSG(ABS_ESP_G_MSG& msg) {
        double factor;
        double offset;
        factor = CDPActive.factor;
        offset = CDPActive.offset;
        msg.CDPActive = *reinterpret_cast<std::decay<decltype(msg.CDPActive)>::type*>(&CDPActive.signal);
        msg.CDPActive = msg.CDPActive * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ABS_ESP_G_MSG can_struct;
        CanParser2CanStruct_ABS_ESP_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ABS_ESP_G_MSGMsg>();
        Struct2Proto_ABS_ESP_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("abs_esp_g") != nullptr) {
            DFHLOG_I("abs_esp_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("abs_esp_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port abs_esp_g");
            return false;
         }
    }
};

struct BCM_1_Parser {
    SignalParser RHTurnlightSts;

    SignalParser LHTurnlightSts;

    SignalParser HighBeamSts;

    SignalParser LowBeamSts;

    SignalParser KeySts;

    SignalParser BCM_1_Checksum;

    SignalParser DirectionIndRight;

    SignalParser DirectionIndLeft;

    SignalParser HazardLightSW;

    SignalParser AutoLightSW;

    SignalParser DriverDoorLockSts;

    SignalParser DriverDoorSts;

    SignalParser PsngrDoorSts;

    SignalParser HoodSts;

    SignalParser RHRDoorSts;

    SignalParser LHRdoorSts;

    SignalParser TrunkSts;

    SignalParser DriverDoorStsQbit;

    SignalParser HMASW;

    SignalParser RearFogLightSts;

    SignalParser ReverseGearSts;

    SignalParser FrontFogLightSts;

    SignalParser HighBeamSWSts;

    SignalParser FlashSWSts;

    SignalParser LHTurnSW;

    SignalParser RHTurnSW;

    SignalParser WiperSts;

    SignalParser AutoHighSpeedRequest;

    SignalParser BCM_1_MessageCounter;

    BCM_1_Parser() {
        RHTurnlightSts = CanConfiguration::Instance().SignalParsers()["RHTurnlightSts"];
        LHTurnlightSts = CanConfiguration::Instance().SignalParsers()["LHTurnlightSts"];
        HighBeamSts = CanConfiguration::Instance().SignalParsers()["HighBeamSts"];
        LowBeamSts = CanConfiguration::Instance().SignalParsers()["LowBeamSts"];
        KeySts = CanConfiguration::Instance().SignalParsers()["KeySts"];
        BCM_1_Checksum = CanConfiguration::Instance().SignalParsers()["BCM_1_Checksum"];
        DirectionIndRight = CanConfiguration::Instance().SignalParsers()["DirectionIndRight"];
        DirectionIndLeft = CanConfiguration::Instance().SignalParsers()["DirectionIndLeft"];
        HazardLightSW = CanConfiguration::Instance().SignalParsers()["HazardLightSW"];
        AutoLightSW = CanConfiguration::Instance().SignalParsers()["AutoLightSW"];
        DriverDoorLockSts = CanConfiguration::Instance().SignalParsers()["DriverDoorLockSts"];
        DriverDoorSts = CanConfiguration::Instance().SignalParsers()["DriverDoorSts"];
        PsngrDoorSts = CanConfiguration::Instance().SignalParsers()["PsngrDoorSts"];
        HoodSts = CanConfiguration::Instance().SignalParsers()["HoodSts"];
        RHRDoorSts = CanConfiguration::Instance().SignalParsers()["RHRDoorSts"];
        LHRdoorSts = CanConfiguration::Instance().SignalParsers()["LHRdoorSts"];
        TrunkSts = CanConfiguration::Instance().SignalParsers()["TrunkSts"];
        DriverDoorStsQbit = CanConfiguration::Instance().SignalParsers()["DriverDoorStsQbit"];
        HMASW = CanConfiguration::Instance().SignalParsers()["HMASW"];
        RearFogLightSts = CanConfiguration::Instance().SignalParsers()["RearFogLightSts"];
        ReverseGearSts = CanConfiguration::Instance().SignalParsers()["ReverseGearSts"];
        FrontFogLightSts = CanConfiguration::Instance().SignalParsers()["FrontFogLightSts"];
        HighBeamSWSts = CanConfiguration::Instance().SignalParsers()["HighBeamSWSts"];
        FlashSWSts = CanConfiguration::Instance().SignalParsers()["FlashSWSts"];
        LHTurnSW = CanConfiguration::Instance().SignalParsers()["LHTurnSW"];
        RHTurnSW = CanConfiguration::Instance().SignalParsers()["RHTurnSW"];
        WiperSts = CanConfiguration::Instance().SignalParsers()["WiperSts"];
        AutoHighSpeedRequest = CanConfiguration::Instance().SignalParsers()["AutoHighSpeedRequest"];
        BCM_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["BCM_1_MessageCounter"];
    }

    void Parser(uint8_t* payload){
        RHTurnlightSts.Parser(payload);
        LHTurnlightSts.Parser(payload);
        HighBeamSts.Parser(payload);
        LowBeamSts.Parser(payload);
        KeySts.Parser(payload);
        BCM_1_Checksum.Parser(payload);
        DirectionIndRight.Parser(payload);
        DirectionIndLeft.Parser(payload);
        HazardLightSW.Parser(payload);
        AutoLightSW.Parser(payload);
        DriverDoorLockSts.Parser(payload);
        DriverDoorSts.Parser(payload);
        PsngrDoorSts.Parser(payload);
        HoodSts.Parser(payload);
        RHRDoorSts.Parser(payload);
        LHRdoorSts.Parser(payload);
        TrunkSts.Parser(payload);
        DriverDoorStsQbit.Parser(payload);
        HMASW.Parser(payload);
        RearFogLightSts.Parser(payload);
        ReverseGearSts.Parser(payload);
        FrontFogLightSts.Parser(payload);
        HighBeamSWSts.Parser(payload);
        FlashSWSts.Parser(payload);
        LHTurnSW.Parser(payload);
        RHTurnSW.Parser(payload);
        WiperSts.Parser(payload);
        AutoHighSpeedRequest.Parser(payload);
        BCM_1_MessageCounter.Parser(payload);
    }

    void CanParser2CanStruct_BCM_1_MSG(BCM_1_MSG& msg) {
        double factor;
        double offset;
        factor = RHTurnlightSts.factor;
        offset = RHTurnlightSts.offset;
        msg.RHTurnlightSts = *reinterpret_cast<std::decay<decltype(msg.RHTurnlightSts)>::type*>(&RHTurnlightSts.signal);
        msg.RHTurnlightSts = msg.RHTurnlightSts * factor + offset;
        factor = LHTurnlightSts.factor;
        offset = LHTurnlightSts.offset;
        msg.LHTurnlightSts = *reinterpret_cast<std::decay<decltype(msg.LHTurnlightSts)>::type*>(&LHTurnlightSts.signal);
        msg.LHTurnlightSts = msg.LHTurnlightSts * factor + offset;
        factor = HighBeamSts.factor;
        offset = HighBeamSts.offset;
        msg.HighBeamSts = *reinterpret_cast<std::decay<decltype(msg.HighBeamSts)>::type*>(&HighBeamSts.signal);
        msg.HighBeamSts = msg.HighBeamSts * factor + offset;
        factor = LowBeamSts.factor;
        offset = LowBeamSts.offset;
        msg.LowBeamSts = *reinterpret_cast<std::decay<decltype(msg.LowBeamSts)>::type*>(&LowBeamSts.signal);
        msg.LowBeamSts = msg.LowBeamSts * factor + offset;
        factor = KeySts.factor;
        offset = KeySts.offset;
        msg.KeySts = *reinterpret_cast<std::decay<decltype(msg.KeySts)>::type*>(&KeySts.signal);
        msg.KeySts = msg.KeySts * factor + offset;
        factor = BCM_1_Checksum.factor;
        offset = BCM_1_Checksum.offset;
        msg.BCM_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.BCM_1_Checksum)>::type*>(&BCM_1_Checksum.signal);
        msg.BCM_1_Checksum = msg.BCM_1_Checksum * factor + offset;
        factor = DirectionIndRight.factor;
        offset = DirectionIndRight.offset;
        msg.DirectionIndRight = *reinterpret_cast<std::decay<decltype(msg.DirectionIndRight)>::type*>(&DirectionIndRight.signal);
        msg.DirectionIndRight = msg.DirectionIndRight * factor + offset;
        factor = DirectionIndLeft.factor;
        offset = DirectionIndLeft.offset;
        msg.DirectionIndLeft = *reinterpret_cast<std::decay<decltype(msg.DirectionIndLeft)>::type*>(&DirectionIndLeft.signal);
        msg.DirectionIndLeft = msg.DirectionIndLeft * factor + offset;
        factor = HazardLightSW.factor;
        offset = HazardLightSW.offset;
        msg.HazardLightSW = *reinterpret_cast<std::decay<decltype(msg.HazardLightSW)>::type*>(&HazardLightSW.signal);
        msg.HazardLightSW = msg.HazardLightSW * factor + offset;
        factor = AutoLightSW.factor;
        offset = AutoLightSW.offset;
        msg.AutoLightSW = *reinterpret_cast<std::decay<decltype(msg.AutoLightSW)>::type*>(&AutoLightSW.signal);
        msg.AutoLightSW = msg.AutoLightSW * factor + offset;
        factor = DriverDoorLockSts.factor;
        offset = DriverDoorLockSts.offset;
        msg.DriverDoorLockSts = *reinterpret_cast<std::decay<decltype(msg.DriverDoorLockSts)>::type*>(&DriverDoorLockSts.signal);
        msg.DriverDoorLockSts = msg.DriverDoorLockSts * factor + offset;
        factor = DriverDoorSts.factor;
        offset = DriverDoorSts.offset;
        msg.DriverDoorSts = *reinterpret_cast<std::decay<decltype(msg.DriverDoorSts)>::type*>(&DriverDoorSts.signal);
        msg.DriverDoorSts = msg.DriverDoorSts * factor + offset;
        factor = PsngrDoorSts.factor;
        offset = PsngrDoorSts.offset;
        msg.PsngrDoorSts = *reinterpret_cast<std::decay<decltype(msg.PsngrDoorSts)>::type*>(&PsngrDoorSts.signal);
        msg.PsngrDoorSts = msg.PsngrDoorSts * factor + offset;
        factor = HoodSts.factor;
        offset = HoodSts.offset;
        msg.HoodSts = *reinterpret_cast<std::decay<decltype(msg.HoodSts)>::type*>(&HoodSts.signal);
        msg.HoodSts = msg.HoodSts * factor + offset;
        factor = RHRDoorSts.factor;
        offset = RHRDoorSts.offset;
        msg.RHRDoorSts = *reinterpret_cast<std::decay<decltype(msg.RHRDoorSts)>::type*>(&RHRDoorSts.signal);
        msg.RHRDoorSts = msg.RHRDoorSts * factor + offset;
        factor = LHRdoorSts.factor;
        offset = LHRdoorSts.offset;
        msg.LHRdoorSts = *reinterpret_cast<std::decay<decltype(msg.LHRdoorSts)>::type*>(&LHRdoorSts.signal);
        msg.LHRdoorSts = msg.LHRdoorSts * factor + offset;
        factor = TrunkSts.factor;
        offset = TrunkSts.offset;
        msg.TrunkSts = *reinterpret_cast<std::decay<decltype(msg.TrunkSts)>::type*>(&TrunkSts.signal);
        msg.TrunkSts = msg.TrunkSts * factor + offset;
        factor = DriverDoorStsQbit.factor;
        offset = DriverDoorStsQbit.offset;
        msg.DriverDoorStsQbit = *reinterpret_cast<std::decay<decltype(msg.DriverDoorStsQbit)>::type*>(&DriverDoorStsQbit.signal);
        msg.DriverDoorStsQbit = msg.DriverDoorStsQbit * factor + offset;
        factor = HMASW.factor;
        offset = HMASW.offset;
        msg.HMASW = *reinterpret_cast<std::decay<decltype(msg.HMASW)>::type*>(&HMASW.signal);
        msg.HMASW = msg.HMASW * factor + offset;
        factor = RearFogLightSts.factor;
        offset = RearFogLightSts.offset;
        msg.RearFogLightSts = *reinterpret_cast<std::decay<decltype(msg.RearFogLightSts)>::type*>(&RearFogLightSts.signal);
        msg.RearFogLightSts = msg.RearFogLightSts * factor + offset;
        factor = ReverseGearSts.factor;
        offset = ReverseGearSts.offset;
        msg.ReverseGearSts = *reinterpret_cast<std::decay<decltype(msg.ReverseGearSts)>::type*>(&ReverseGearSts.signal);
        msg.ReverseGearSts = msg.ReverseGearSts * factor + offset;
        factor = FrontFogLightSts.factor;
        offset = FrontFogLightSts.offset;
        msg.FrontFogLightSts = *reinterpret_cast<std::decay<decltype(msg.FrontFogLightSts)>::type*>(&FrontFogLightSts.signal);
        msg.FrontFogLightSts = msg.FrontFogLightSts * factor + offset;
        factor = HighBeamSWSts.factor;
        offset = HighBeamSWSts.offset;
        msg.HighBeamSWSts = *reinterpret_cast<std::decay<decltype(msg.HighBeamSWSts)>::type*>(&HighBeamSWSts.signal);
        msg.HighBeamSWSts = msg.HighBeamSWSts * factor + offset;
        factor = FlashSWSts.factor;
        offset = FlashSWSts.offset;
        msg.FlashSWSts = *reinterpret_cast<std::decay<decltype(msg.FlashSWSts)>::type*>(&FlashSWSts.signal);
        msg.FlashSWSts = msg.FlashSWSts * factor + offset;
        factor = LHTurnSW.factor;
        offset = LHTurnSW.offset;
        msg.LHTurnSW = *reinterpret_cast<std::decay<decltype(msg.LHTurnSW)>::type*>(&LHTurnSW.signal);
        msg.LHTurnSW = msg.LHTurnSW * factor + offset;
        factor = RHTurnSW.factor;
        offset = RHTurnSW.offset;
        msg.RHTurnSW = *reinterpret_cast<std::decay<decltype(msg.RHTurnSW)>::type*>(&RHTurnSW.signal);
        msg.RHTurnSW = msg.RHTurnSW * factor + offset;
        factor = WiperSts.factor;
        offset = WiperSts.offset;
        msg.WiperSts = *reinterpret_cast<std::decay<decltype(msg.WiperSts)>::type*>(&WiperSts.signal);
        msg.WiperSts = msg.WiperSts * factor + offset;
        factor = AutoHighSpeedRequest.factor;
        offset = AutoHighSpeedRequest.offset;
        msg.AutoHighSpeedRequest = *reinterpret_cast<std::decay<decltype(msg.AutoHighSpeedRequest)>::type*>(&AutoHighSpeedRequest.signal);
        msg.AutoHighSpeedRequest = msg.AutoHighSpeedRequest * factor + offset;
        factor = BCM_1_MessageCounter.factor;
        offset = BCM_1_MessageCounter.offset;
        msg.BCM_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.BCM_1_MessageCounter)>::type*>(&BCM_1_MessageCounter.signal);
        msg.BCM_1_MessageCounter = msg.BCM_1_MessageCounter * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_1_MSG can_struct;
        CanParser2CanStruct_BCM_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_1_MSGMsg>();
        Struct2Proto_BCM_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_1") != nullptr) {
            DFHLOG_I("bcm_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_1");
            return false;
         }
    }
};

struct BCM_4_Parser {
    SignalParser BCM_4_ArmingSts;

    SignalParser LightDetected;

    SignalParser RVSMode;

    SignalParser BrakelampFaultSts;

    BCM_4_Parser() {
        BCM_4_ArmingSts = CanConfiguration::Instance().SignalParsers()["BCM_4_ArmingSts"];
        LightDetected = CanConfiguration::Instance().SignalParsers()["LightDetected"];
        RVSMode = CanConfiguration::Instance().SignalParsers()["RVSMode"];
        BrakelampFaultSts = CanConfiguration::Instance().SignalParsers()["BrakelampFaultSts"];
    }

    void Parser(uint8_t* payload){
        BCM_4_ArmingSts.Parser(payload);
        LightDetected.Parser(payload);
        RVSMode.Parser(payload);
        BrakelampFaultSts.Parser(payload);
    }

    void CanParser2CanStruct_BCM_4_MSG(BCM_4_MSG& msg) {
        double factor;
        double offset;
        factor = BCM_4_ArmingSts.factor;
        offset = BCM_4_ArmingSts.offset;
        msg.BCM_4_ArmingSts = *reinterpret_cast<std::decay<decltype(msg.BCM_4_ArmingSts)>::type*>(&BCM_4_ArmingSts.signal);
        msg.BCM_4_ArmingSts = msg.BCM_4_ArmingSts * factor + offset;
        factor = LightDetected.factor;
        offset = LightDetected.offset;
        msg.LightDetected = *reinterpret_cast<std::decay<decltype(msg.LightDetected)>::type*>(&LightDetected.signal);
        msg.LightDetected = msg.LightDetected * factor + offset;
        factor = RVSMode.factor;
        offset = RVSMode.offset;
        msg.RVSMode = *reinterpret_cast<std::decay<decltype(msg.RVSMode)>::type*>(&RVSMode.signal);
        msg.RVSMode = msg.RVSMode * factor + offset;
        factor = BrakelampFaultSts.factor;
        offset = BrakelampFaultSts.offset;
        msg.BrakelampFaultSts = *reinterpret_cast<std::decay<decltype(msg.BrakelampFaultSts)>::type*>(&BrakelampFaultSts.signal);
        msg.BrakelampFaultSts = msg.BrakelampFaultSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_4_MSG can_struct;
        CanParser2CanStruct_BCM_4_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_4_MSGMsg>();
        Struct2Proto_BCM_4_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_4") != nullptr) {
            DFHLOG_I("bcm_4");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_4")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_4");
            return false;
         }
    }
};

struct BCM_5_Parser {
    SignalParser TirePositionWarning_LHFTire;

    SignalParser TirePositionWarning_RHFTire;

    SignalParser TirePositionWarning_LHRTire;

    SignalParser TirePositionWarning_RHRTire;

    BCM_5_Parser() {
        TirePositionWarning_LHFTire = CanConfiguration::Instance().SignalParsers()["TirePositionWarning_LHFTire"];
        TirePositionWarning_RHFTire = CanConfiguration::Instance().SignalParsers()["TirePositionWarning_RHFTire"];
        TirePositionWarning_LHRTire = CanConfiguration::Instance().SignalParsers()["TirePositionWarning_LHRTire"];
        TirePositionWarning_RHRTire = CanConfiguration::Instance().SignalParsers()["TirePositionWarning_RHRTire"];
    }

    void Parser(uint8_t* payload){
        TirePositionWarning_LHFTire.Parser(payload);
        TirePositionWarning_RHFTire.Parser(payload);
        TirePositionWarning_LHRTire.Parser(payload);
        TirePositionWarning_RHRTire.Parser(payload);
    }

    void CanParser2CanStruct_BCM_5_MSG(BCM_5_MSG& msg) {
        double factor;
        double offset;
        factor = TirePositionWarning_LHFTire.factor;
        offset = TirePositionWarning_LHFTire.offset;
        msg.TirePositionWarning_LHFTire = *reinterpret_cast<std::decay<decltype(msg.TirePositionWarning_LHFTire)>::type*>(&TirePositionWarning_LHFTire.signal);
        msg.TirePositionWarning_LHFTire = msg.TirePositionWarning_LHFTire * factor + offset;
        factor = TirePositionWarning_RHFTire.factor;
        offset = TirePositionWarning_RHFTire.offset;
        msg.TirePositionWarning_RHFTire = *reinterpret_cast<std::decay<decltype(msg.TirePositionWarning_RHFTire)>::type*>(&TirePositionWarning_RHFTire.signal);
        msg.TirePositionWarning_RHFTire = msg.TirePositionWarning_RHFTire * factor + offset;
        factor = TirePositionWarning_LHRTire.factor;
        offset = TirePositionWarning_LHRTire.offset;
        msg.TirePositionWarning_LHRTire = *reinterpret_cast<std::decay<decltype(msg.TirePositionWarning_LHRTire)>::type*>(&TirePositionWarning_LHRTire.signal);
        msg.TirePositionWarning_LHRTire = msg.TirePositionWarning_LHRTire * factor + offset;
        factor = TirePositionWarning_RHRTire.factor;
        offset = TirePositionWarning_RHRTire.offset;
        msg.TirePositionWarning_RHRTire = *reinterpret_cast<std::decay<decltype(msg.TirePositionWarning_RHRTire)>::type*>(&TirePositionWarning_RHRTire.signal);
        msg.TirePositionWarning_RHRTire = msg.TirePositionWarning_RHRTire * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_5_MSG can_struct;
        CanParser2CanStruct_BCM_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_5_MSGMsg>();
        Struct2Proto_BCM_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_5") != nullptr) {
            DFHLOG_I("bcm_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_5");
            return false;
         }
    }
};

struct BCM_9_Parser {
    SignalParser SRF_OperateSts;

    SignalParser SRF_PositionSts;

    SignalParser FLWindow_Sts;

    SignalParser FRWindow_Sts;

    SignalParser RLWindowSts;

    SignalParser RRWindowSts;

    SignalParser TrailerConnectSts;

    BCM_9_Parser() {
        SRF_OperateSts = CanConfiguration::Instance().SignalParsers()["SRF_OperateSts"];
        SRF_PositionSts = CanConfiguration::Instance().SignalParsers()["SRF_PositionSts"];
        FLWindow_Sts = CanConfiguration::Instance().SignalParsers()["FLWindow_Sts"];
        FRWindow_Sts = CanConfiguration::Instance().SignalParsers()["FRWindow_Sts"];
        RLWindowSts = CanConfiguration::Instance().SignalParsers()["RLWindowSts"];
        RRWindowSts = CanConfiguration::Instance().SignalParsers()["RRWindowSts"];
        TrailerConnectSts = CanConfiguration::Instance().SignalParsers()["TrailerConnectSts"];
    }

    void Parser(uint8_t* payload){
        SRF_OperateSts.Parser(payload);
        SRF_PositionSts.Parser(payload);
        FLWindow_Sts.Parser(payload);
        FRWindow_Sts.Parser(payload);
        RLWindowSts.Parser(payload);
        RRWindowSts.Parser(payload);
        TrailerConnectSts.Parser(payload);
    }

    void CanParser2CanStruct_BCM_9_MSG(BCM_9_MSG& msg) {
        double factor;
        double offset;
        factor = SRF_OperateSts.factor;
        offset = SRF_OperateSts.offset;
        msg.SRF_OperateSts = *reinterpret_cast<std::decay<decltype(msg.SRF_OperateSts)>::type*>(&SRF_OperateSts.signal);
        msg.SRF_OperateSts = msg.SRF_OperateSts * factor + offset;
        factor = SRF_PositionSts.factor;
        offset = SRF_PositionSts.offset;
        msg.SRF_PositionSts = *reinterpret_cast<std::decay<decltype(msg.SRF_PositionSts)>::type*>(&SRF_PositionSts.signal);
        msg.SRF_PositionSts = msg.SRF_PositionSts * factor + offset;
        factor = FLWindow_Sts.factor;
        offset = FLWindow_Sts.offset;
        msg.FLWindow_Sts = *reinterpret_cast<std::decay<decltype(msg.FLWindow_Sts)>::type*>(&FLWindow_Sts.signal);
        msg.FLWindow_Sts = msg.FLWindow_Sts * factor + offset;
        factor = FRWindow_Sts.factor;
        offset = FRWindow_Sts.offset;
        msg.FRWindow_Sts = *reinterpret_cast<std::decay<decltype(msg.FRWindow_Sts)>::type*>(&FRWindow_Sts.signal);
        msg.FRWindow_Sts = msg.FRWindow_Sts * factor + offset;
        factor = RLWindowSts.factor;
        offset = RLWindowSts.offset;
        msg.RLWindowSts = *reinterpret_cast<std::decay<decltype(msg.RLWindowSts)>::type*>(&RLWindowSts.signal);
        msg.RLWindowSts = msg.RLWindowSts * factor + offset;
        factor = RRWindowSts.factor;
        offset = RRWindowSts.offset;
        msg.RRWindowSts = *reinterpret_cast<std::decay<decltype(msg.RRWindowSts)>::type*>(&RRWindowSts.signal);
        msg.RRWindowSts = msg.RRWindowSts * factor + offset;
        factor = TrailerConnectSts.factor;
        offset = TrailerConnectSts.offset;
        msg.TrailerConnectSts = *reinterpret_cast<std::decay<decltype(msg.TrailerConnectSts)>::type*>(&TrailerConnectSts.signal);
        msg.TrailerConnectSts = msg.TrailerConnectSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_9_MSG can_struct;
        CanParser2CanStruct_BCM_9_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_9_MSGMsg>();
        Struct2Proto_BCM_9_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_9") != nullptr) {
            DFHLOG_I("bcm_9");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_9")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_9");
            return false;
         }
    }
};

struct BCM_10_Parser {
    SignalParser BCM_10_Config;

    BCM_10_Parser() {
        BCM_10_Config = CanConfiguration::Instance().SignalParsers()["BCM_10_Config"];
    }

    void Parser(uint8_t* payload){
        BCM_10_Config.Parser(payload);
    }

    void CanParser2CanStruct_BCM_10_MSG(BCM_10_MSG& msg) {
        double factor;
        double offset;
        factor = BCM_10_Config.factor;
        offset = BCM_10_Config.offset;
        msg.BCM_10_Config = *reinterpret_cast<std::decay<decltype(msg.BCM_10_Config)>::type*>(&BCM_10_Config.signal);
        msg.BCM_10_Config = msg.BCM_10_Config * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_10_MSG can_struct;
        CanParser2CanStruct_BCM_10_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_10_MSGMsg>();
        Struct2Proto_BCM_10_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_10") != nullptr) {
            DFHLOG_I("bcm_10");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_10")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_10");
            return false;
         }
    }
};

struct BCM_11_Parser {
    SignalParser HUDBriRawVal;

    SignalParser HUDBriUnit;

    SignalParser Rainfall;

    BCM_11_Parser() {
        HUDBriRawVal = CanConfiguration::Instance().SignalParsers()["HUDBriRawVal"];
        HUDBriUnit = CanConfiguration::Instance().SignalParsers()["HUDBriUnit"];
        Rainfall = CanConfiguration::Instance().SignalParsers()["Rainfall"];
    }

    void Parser(uint8_t* payload){
        HUDBriRawVal.Parser(payload);
        HUDBriUnit.Parser(payload);
        Rainfall.Parser(payload);
    }

    void CanParser2CanStruct_BCM_11_MSG(BCM_11_MSG& msg) {
        double factor;
        double offset;
        factor = HUDBriRawVal.factor;
        offset = HUDBriRawVal.offset;
        msg.HUDBriRawVal = *reinterpret_cast<std::decay<decltype(msg.HUDBriRawVal)>::type*>(&HUDBriRawVal.signal);
        msg.HUDBriRawVal = msg.HUDBriRawVal * factor + offset;
        factor = HUDBriUnit.factor;
        offset = HUDBriUnit.offset;
        msg.HUDBriUnit = *reinterpret_cast<std::decay<decltype(msg.HUDBriUnit)>::type*>(&HUDBriUnit.signal);
        msg.HUDBriUnit = msg.HUDBriUnit * factor + offset;
        factor = Rainfall.factor;
        offset = Rainfall.offset;
        msg.Rainfall = *reinterpret_cast<std::decay<decltype(msg.Rainfall)>::type*>(&Rainfall.signal);
        msg.Rainfall = msg.Rainfall * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_11_MSG can_struct;
        CanParser2CanStruct_BCM_11_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_11_MSGMsg>();
        Struct2Proto_BCM_11_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_11") != nullptr) {
            DFHLOG_I("bcm_11");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_11")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_11");
            return false;
         }
    }
};

struct BCM_13_Parser {
    SignalParser IBS_SOC;

    BCM_13_Parser() {
        IBS_SOC = CanConfiguration::Instance().SignalParsers()["IBS_SOC"];
    }

    void Parser(uint8_t* payload){
        IBS_SOC.Parser(payload);
    }

    void CanParser2CanStruct_BCM_13_MSG(BCM_13_MSG& msg) {
        double factor;
        double offset;
        factor = IBS_SOC.factor;
        offset = IBS_SOC.offset;
        msg.IBS_SOC = *reinterpret_cast<std::decay<decltype(msg.IBS_SOC)>::type*>(&IBS_SOC.signal);
        msg.IBS_SOC = msg.IBS_SOC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_13_MSG can_struct;
        CanParser2CanStruct_BCM_13_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_13_MSGMsg>();
        Struct2Proto_BCM_13_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_13") != nullptr) {
            DFHLOG_I("bcm_13");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_13")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_13");
            return false;
         }
    }
};

struct BCM_17_Parser {
    SignalParser BCM_17_Resd;

    BCM_17_Parser() {
        BCM_17_Resd = CanConfiguration::Instance().SignalParsers()["BCM_17_Resd"];
    }

    void Parser(uint8_t* payload){
        BCM_17_Resd.Parser(payload);
    }

    void CanParser2CanStruct_BCM_17_MSG(BCM_17_MSG& msg) {
        double factor;
        double offset;
        factor = BCM_17_Resd.factor;
        offset = BCM_17_Resd.offset;
        msg.BCM_17_Resd = *reinterpret_cast<std::decay<decltype(msg.BCM_17_Resd)>::type*>(&BCM_17_Resd.signal);
        msg.BCM_17_Resd = msg.BCM_17_Resd * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BCM_17_MSG can_struct;
        CanParser2CanStruct_BCM_17_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BCM_17_MSGMsg>();
        Struct2Proto_BCM_17_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bcm_17") != nullptr) {
            DFHLOG_I("bcm_17");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bcm_17")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bcm_17");
            return false;
         }
    }
};

struct BMS_8_Parser {
    SignalParser BMSH_8_MessageCounter;

    SignalParser BMSH_8_CRC;

    SignalParser BMS_8_CC2Sts;

    BMS_8_Parser() {
        BMSH_8_MessageCounter = CanConfiguration::Instance().SignalParsers()["BMSH_8_MessageCounter"];
        BMSH_8_CRC = CanConfiguration::Instance().SignalParsers()["BMSH_8_CRC"];
        BMS_8_CC2Sts = CanConfiguration::Instance().SignalParsers()["BMS_8_CC2Sts"];
    }

    void Parser(uint8_t* payload){
        BMSH_8_MessageCounter.Parser(payload);
        BMSH_8_CRC.Parser(payload);
        BMS_8_CC2Sts.Parser(payload);
    }

    void CanParser2CanStruct_BMS_8_MSG(BMS_8_MSG& msg) {
        double factor;
        double offset;
        factor = BMSH_8_MessageCounter.factor;
        offset = BMSH_8_MessageCounter.offset;
        msg.BMSH_8_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.BMSH_8_MessageCounter)>::type*>(&BMSH_8_MessageCounter.signal);
        msg.BMSH_8_MessageCounter = msg.BMSH_8_MessageCounter * factor + offset;
        factor = BMSH_8_CRC.factor;
        offset = BMSH_8_CRC.offset;
        msg.BMSH_8_CRC = *reinterpret_cast<std::decay<decltype(msg.BMSH_8_CRC)>::type*>(&BMSH_8_CRC.signal);
        msg.BMSH_8_CRC = msg.BMSH_8_CRC * factor + offset;
        factor = BMS_8_CC2Sts.factor;
        offset = BMS_8_CC2Sts.offset;
        msg.BMS_8_CC2Sts = *reinterpret_cast<std::decay<decltype(msg.BMS_8_CC2Sts)>::type*>(&BMS_8_CC2Sts.signal);
        msg.BMS_8_CC2Sts = msg.BMS_8_CC2Sts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BMS_8_MSG can_struct;
        CanParser2CanStruct_BMS_8_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BMS_8_MSGMsg>();
        Struct2Proto_BMS_8_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bms_8") != nullptr) {
            DFHLOG_I("bms_8");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bms_8")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bms_8");
            return false;
         }
    }
};

struct CLM_2_Parser {
    SignalParser CLM2_AliveCounter;

    SignalParser CLM2_ExternalTempFailSts;

    SignalParser CLM2_ExternalTemperature_C;

    SignalParser ExternalTemperatureFailSts_GS;

    SignalParser ExternalTemperatureRaw_C;

    SignalParser CLM2_CRC;

    CLM_2_Parser() {
        CLM2_AliveCounter = CanConfiguration::Instance().SignalParsers()["CLM2_AliveCounter"];
        CLM2_ExternalTempFailSts = CanConfiguration::Instance().SignalParsers()["CLM2_ExternalTempFailSts"];
        CLM2_ExternalTemperature_C = CanConfiguration::Instance().SignalParsers()["CLM2_ExternalTemperature_C"];
        ExternalTemperatureFailSts_GS = CanConfiguration::Instance().SignalParsers()["ExternalTemperatureFailSts_GS"];
        ExternalTemperatureRaw_C = CanConfiguration::Instance().SignalParsers()["ExternalTemperatureRaw_C"];
        CLM2_CRC = CanConfiguration::Instance().SignalParsers()["CLM2_CRC"];
    }

    void Parser(uint8_t* payload){
        CLM2_AliveCounter.Parser(payload);
        CLM2_ExternalTempFailSts.Parser(payload);
        CLM2_ExternalTemperature_C.Parser(payload);
        ExternalTemperatureFailSts_GS.Parser(payload);
        ExternalTemperatureRaw_C.Parser(payload);
        CLM2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_CLM_2_MSG(CLM_2_MSG& msg) {
        double factor;
        double offset;
        factor = CLM2_AliveCounter.factor;
        offset = CLM2_AliveCounter.offset;
        msg.CLM2_AliveCounter = *reinterpret_cast<std::decay<decltype(msg.CLM2_AliveCounter)>::type*>(&CLM2_AliveCounter.signal);
        msg.CLM2_AliveCounter = msg.CLM2_AliveCounter * factor + offset;
        factor = CLM2_ExternalTempFailSts.factor;
        offset = CLM2_ExternalTempFailSts.offset;
        msg.CLM2_ExternalTempFailSts = *reinterpret_cast<std::decay<decltype(msg.CLM2_ExternalTempFailSts)>::type*>(&CLM2_ExternalTempFailSts.signal);
        msg.CLM2_ExternalTempFailSts = msg.CLM2_ExternalTempFailSts * factor + offset;
        factor = CLM2_ExternalTemperature_C.factor;
        offset = CLM2_ExternalTemperature_C.offset;
        msg.CLM2_ExternalTemperature_C = *reinterpret_cast<std::decay<decltype(msg.CLM2_ExternalTemperature_C)>::type*>(&CLM2_ExternalTemperature_C.signal);
        msg.CLM2_ExternalTemperature_C = msg.CLM2_ExternalTemperature_C * factor + offset;
        factor = ExternalTemperatureFailSts_GS.factor;
        offset = ExternalTemperatureFailSts_GS.offset;
        msg.ExternalTemperatureFailSts_GS = *reinterpret_cast<std::decay<decltype(msg.ExternalTemperatureFailSts_GS)>::type*>(&ExternalTemperatureFailSts_GS.signal);
        msg.ExternalTemperatureFailSts_GS = msg.ExternalTemperatureFailSts_GS * factor + offset;
        factor = ExternalTemperatureRaw_C.factor;
        offset = ExternalTemperatureRaw_C.offset;
        msg.ExternalTemperatureRaw_C = *reinterpret_cast<std::decay<decltype(msg.ExternalTemperatureRaw_C)>::type*>(&ExternalTemperatureRaw_C.signal);
        msg.ExternalTemperatureRaw_C = msg.ExternalTemperatureRaw_C * factor + offset;
        factor = CLM2_CRC.factor;
        offset = CLM2_CRC.offset;
        msg.CLM2_CRC = *reinterpret_cast<std::decay<decltype(msg.CLM2_CRC)>::type*>(&CLM2_CRC.signal);
        msg.CLM2_CRC = msg.CLM2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        CLM_2_MSG can_struct;
        CanParser2CanStruct_CLM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::CLM_2_MSGMsg>();
        Struct2Proto_CLM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("clm_2") != nullptr) {
            DFHLOG_I("clm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("clm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port clm_2");
            return false;
         }
    }
};

struct DMS_1_Parser {
    SignalParser DMS_1_DrvrDistrLvl;

    SignalParser DMS_1_DrvrFatiLvl;

    SignalParser DMS_1_DMSSt;

    SignalParser DMS_1_DrvrDistrLvlCfdec;

    SignalParser DMS_1_DrvrFatiLvlCfdec;

    SignalParser DMS_1_CameraSt;

    SignalParser DMS_1_MessageCounter;

    SignalParser DMS_1_CRC;

    DMS_1_Parser() {
        DMS_1_DrvrDistrLvl = CanConfiguration::Instance().SignalParsers()["DMS_1_DrvrDistrLvl"];
        DMS_1_DrvrFatiLvl = CanConfiguration::Instance().SignalParsers()["DMS_1_DrvrFatiLvl"];
        DMS_1_DMSSt = CanConfiguration::Instance().SignalParsers()["DMS_1_DMSSt"];
        DMS_1_DrvrDistrLvlCfdec = CanConfiguration::Instance().SignalParsers()["DMS_1_DrvrDistrLvlCfdec"];
        DMS_1_DrvrFatiLvlCfdec = CanConfiguration::Instance().SignalParsers()["DMS_1_DrvrFatiLvlCfdec"];
        DMS_1_CameraSt = CanConfiguration::Instance().SignalParsers()["DMS_1_CameraSt"];
        DMS_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["DMS_1_MessageCounter"];
        DMS_1_CRC = CanConfiguration::Instance().SignalParsers()["DMS_1_CRC"];
    }

    void Parser(uint8_t* payload){
        DMS_1_DrvrDistrLvl.Parser(payload);
        DMS_1_DrvrFatiLvl.Parser(payload);
        DMS_1_DMSSt.Parser(payload);
        DMS_1_DrvrDistrLvlCfdec.Parser(payload);
        DMS_1_DrvrFatiLvlCfdec.Parser(payload);
        DMS_1_CameraSt.Parser(payload);
        DMS_1_MessageCounter.Parser(payload);
        DMS_1_CRC.Parser(payload);
    }

    void CanParser2CanStruct_DMS_1_MSG(DMS_1_MSG& msg) {
        double factor;
        double offset;
        factor = DMS_1_DrvrDistrLvl.factor;
        offset = DMS_1_DrvrDistrLvl.offset;
        msg.DMS_1_DrvrDistrLvl = *reinterpret_cast<std::decay<decltype(msg.DMS_1_DrvrDistrLvl)>::type*>(&DMS_1_DrvrDistrLvl.signal);
        msg.DMS_1_DrvrDistrLvl = msg.DMS_1_DrvrDistrLvl * factor + offset;
        factor = DMS_1_DrvrFatiLvl.factor;
        offset = DMS_1_DrvrFatiLvl.offset;
        msg.DMS_1_DrvrFatiLvl = *reinterpret_cast<std::decay<decltype(msg.DMS_1_DrvrFatiLvl)>::type*>(&DMS_1_DrvrFatiLvl.signal);
        msg.DMS_1_DrvrFatiLvl = msg.DMS_1_DrvrFatiLvl * factor + offset;
        factor = DMS_1_DMSSt.factor;
        offset = DMS_1_DMSSt.offset;
        msg.DMS_1_DMSSt = *reinterpret_cast<std::decay<decltype(msg.DMS_1_DMSSt)>::type*>(&DMS_1_DMSSt.signal);
        msg.DMS_1_DMSSt = msg.DMS_1_DMSSt * factor + offset;
        factor = DMS_1_DrvrDistrLvlCfdec.factor;
        offset = DMS_1_DrvrDistrLvlCfdec.offset;
        msg.DMS_1_DrvrDistrLvlCfdec = *reinterpret_cast<std::decay<decltype(msg.DMS_1_DrvrDistrLvlCfdec)>::type*>(&DMS_1_DrvrDistrLvlCfdec.signal);
        msg.DMS_1_DrvrDistrLvlCfdec = msg.DMS_1_DrvrDistrLvlCfdec * factor + offset;
        factor = DMS_1_DrvrFatiLvlCfdec.factor;
        offset = DMS_1_DrvrFatiLvlCfdec.offset;
        msg.DMS_1_DrvrFatiLvlCfdec = *reinterpret_cast<std::decay<decltype(msg.DMS_1_DrvrFatiLvlCfdec)>::type*>(&DMS_1_DrvrFatiLvlCfdec.signal);
        msg.DMS_1_DrvrFatiLvlCfdec = msg.DMS_1_DrvrFatiLvlCfdec * factor + offset;
        factor = DMS_1_CameraSt.factor;
        offset = DMS_1_CameraSt.offset;
        msg.DMS_1_CameraSt = *reinterpret_cast<std::decay<decltype(msg.DMS_1_CameraSt)>::type*>(&DMS_1_CameraSt.signal);
        msg.DMS_1_CameraSt = msg.DMS_1_CameraSt * factor + offset;
        factor = DMS_1_MessageCounter.factor;
        offset = DMS_1_MessageCounter.offset;
        msg.DMS_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.DMS_1_MessageCounter)>::type*>(&DMS_1_MessageCounter.signal);
        msg.DMS_1_MessageCounter = msg.DMS_1_MessageCounter * factor + offset;
        factor = DMS_1_CRC.factor;
        offset = DMS_1_CRC.offset;
        msg.DMS_1_CRC = *reinterpret_cast<std::decay<decltype(msg.DMS_1_CRC)>::type*>(&DMS_1_CRC.signal);
        msg.DMS_1_CRC = msg.DMS_1_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        DMS_1_MSG can_struct;
        CanParser2CanStruct_DMS_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::DMS_1_MSGMsg>();
        Struct2Proto_DMS_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("dms_1") != nullptr) {
            DFHLOG_I("dms_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("dms_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port dms_1");
            return false;
         }
    }
};

struct HCU_EMS_1_Parser {
    SignalParser EMS1_EngineSpeed;

    SignalParser EMS_1_Checksum;

    SignalParser AcceleratorPosRaw;

    SignalParser EMS_1_MessageCounter;

    HCU_EMS_1_Parser() {
        EMS1_EngineSpeed = CanConfiguration::Instance().SignalParsers()["EMS1_EngineSpeed"];
        EMS_1_Checksum = CanConfiguration::Instance().SignalParsers()["EMS_1_Checksum"];
        AcceleratorPosRaw = CanConfiguration::Instance().SignalParsers()["AcceleratorPosRaw"];
        EMS_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["EMS_1_MessageCounter"];
    }

    void Parser(uint8_t* payload){
        EMS1_EngineSpeed.Parser(payload);
        EMS_1_Checksum.Parser(payload);
        AcceleratorPosRaw.Parser(payload);
        EMS_1_MessageCounter.Parser(payload);
    }

    void CanParser2CanStruct_HCU_EMS_1_MSG(HCU_EMS_1_MSG& msg) {
        double factor;
        double offset;
        factor = EMS1_EngineSpeed.factor;
        offset = EMS1_EngineSpeed.offset;
        msg.EMS1_EngineSpeed = *reinterpret_cast<std::decay<decltype(msg.EMS1_EngineSpeed)>::type*>(&EMS1_EngineSpeed.signal);
        msg.EMS1_EngineSpeed = msg.EMS1_EngineSpeed * factor + offset;
        factor = EMS_1_Checksum.factor;
        offset = EMS_1_Checksum.offset;
        msg.EMS_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.EMS_1_Checksum)>::type*>(&EMS_1_Checksum.signal);
        msg.EMS_1_Checksum = msg.EMS_1_Checksum * factor + offset;
        factor = AcceleratorPosRaw.factor;
        offset = AcceleratorPosRaw.offset;
        msg.AcceleratorPosRaw = *reinterpret_cast<std::decay<decltype(msg.AcceleratorPosRaw)>::type*>(&AcceleratorPosRaw.signal);
        msg.AcceleratorPosRaw = msg.AcceleratorPosRaw * factor + offset;
        factor = EMS_1_MessageCounter.factor;
        offset = EMS_1_MessageCounter.offset;
        msg.EMS_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.EMS_1_MessageCounter)>::type*>(&EMS_1_MessageCounter.signal);
        msg.EMS_1_MessageCounter = msg.EMS_1_MessageCounter * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_EMS_1_MSG can_struct;
        CanParser2CanStruct_HCU_EMS_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_EMS_1_MSGMsg>();
        Struct2Proto_HCU_EMS_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_ems_1") != nullptr) {
            DFHLOG_I("hcu_ems_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_ems_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_ems_1");
            return false;
         }
    }
};

struct HCU_EMS_2_Parser {
    SignalParser MaxTorqueAvailable;

    SignalParser MinTorqueAvailable;

    SignalParser BrakePedalStsValidDataForTCU;

    SignalParser BrakePedalStsForTCU;

    SignalParser EngineStsForDCT;

    HCU_EMS_2_Parser() {
        MaxTorqueAvailable = CanConfiguration::Instance().SignalParsers()["MaxTorqueAvailable"];
        MinTorqueAvailable = CanConfiguration::Instance().SignalParsers()["MinTorqueAvailable"];
        BrakePedalStsValidDataForTCU = CanConfiguration::Instance().SignalParsers()["BrakePedalStsValidDataForTCU"];
        BrakePedalStsForTCU = CanConfiguration::Instance().SignalParsers()["BrakePedalStsForTCU"];
        EngineStsForDCT = CanConfiguration::Instance().SignalParsers()["EngineStsForDCT"];
    }

    void Parser(uint8_t* payload){
        MaxTorqueAvailable.Parser(payload);
        MinTorqueAvailable.Parser(payload);
        BrakePedalStsValidDataForTCU.Parser(payload);
        BrakePedalStsForTCU.Parser(payload);
        EngineStsForDCT.Parser(payload);
    }

    void CanParser2CanStruct_HCU_EMS_2_MSG(HCU_EMS_2_MSG& msg) {
        double factor;
        double offset;
        factor = MaxTorqueAvailable.factor;
        offset = MaxTorqueAvailable.offset;
        msg.MaxTorqueAvailable = *reinterpret_cast<std::decay<decltype(msg.MaxTorqueAvailable)>::type*>(&MaxTorqueAvailable.signal);
        msg.MaxTorqueAvailable = msg.MaxTorqueAvailable * factor + offset;
        factor = MinTorqueAvailable.factor;
        offset = MinTorqueAvailable.offset;
        msg.MinTorqueAvailable = *reinterpret_cast<std::decay<decltype(msg.MinTorqueAvailable)>::type*>(&MinTorqueAvailable.signal);
        msg.MinTorqueAvailable = msg.MinTorqueAvailable * factor + offset;
        factor = BrakePedalStsValidDataForTCU.factor;
        offset = BrakePedalStsValidDataForTCU.offset;
        msg.BrakePedalStsValidDataForTCU = *reinterpret_cast<std::decay<decltype(msg.BrakePedalStsValidDataForTCU)>::type*>(&BrakePedalStsValidDataForTCU.signal);
        msg.BrakePedalStsValidDataForTCU = msg.BrakePedalStsValidDataForTCU * factor + offset;
        factor = BrakePedalStsForTCU.factor;
        offset = BrakePedalStsForTCU.offset;
        msg.BrakePedalStsForTCU = *reinterpret_cast<std::decay<decltype(msg.BrakePedalStsForTCU)>::type*>(&BrakePedalStsForTCU.signal);
        msg.BrakePedalStsForTCU = msg.BrakePedalStsForTCU * factor + offset;
        factor = EngineStsForDCT.factor;
        offset = EngineStsForDCT.offset;
        msg.EngineStsForDCT = *reinterpret_cast<std::decay<decltype(msg.EngineStsForDCT)>::type*>(&EngineStsForDCT.signal);
        msg.EngineStsForDCT = msg.EngineStsForDCT * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_EMS_2_MSG can_struct;
        CanParser2CanStruct_HCU_EMS_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_EMS_2_MSGMsg>();
        Struct2Proto_HCU_EMS_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_ems_2") != nullptr) {
            DFHLOG_I("hcu_ems_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_ems_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_ems_2");
            return false;
         }
    }
};

struct HCU_EMS_3_Parser {
    SignalParser MeanEffectiveTorque;

    SignalParser EngineTorqueDriverRequest;

    SignalParser EngineTorqueLoss;

    SignalParser SSMStatus;

    SignalParser EMS_3_MessageCounter;

    SignalParser EMS_3_Checksum;

    HCU_EMS_3_Parser() {
        MeanEffectiveTorque = CanConfiguration::Instance().SignalParsers()["MeanEffectiveTorque"];
        EngineTorqueDriverRequest = CanConfiguration::Instance().SignalParsers()["EngineTorqueDriverRequest"];
        EngineTorqueLoss = CanConfiguration::Instance().SignalParsers()["EngineTorqueLoss"];
        SSMStatus = CanConfiguration::Instance().SignalParsers()["SSMStatus"];
        EMS_3_MessageCounter = CanConfiguration::Instance().SignalParsers()["EMS_3_MessageCounter"];
        EMS_3_Checksum = CanConfiguration::Instance().SignalParsers()["EMS_3_Checksum"];
    }

    void Parser(uint8_t* payload){
        MeanEffectiveTorque.Parser(payload);
        EngineTorqueDriverRequest.Parser(payload);
        EngineTorqueLoss.Parser(payload);
        SSMStatus.Parser(payload);
        EMS_3_MessageCounter.Parser(payload);
        EMS_3_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_HCU_EMS_3_MSG(HCU_EMS_3_MSG& msg) {
        double factor;
        double offset;
        factor = MeanEffectiveTorque.factor;
        offset = MeanEffectiveTorque.offset;
        msg.MeanEffectiveTorque = *reinterpret_cast<std::decay<decltype(msg.MeanEffectiveTorque)>::type*>(&MeanEffectiveTorque.signal);
        msg.MeanEffectiveTorque = msg.MeanEffectiveTorque * factor + offset;
        factor = EngineTorqueDriverRequest.factor;
        offset = EngineTorqueDriverRequest.offset;
        msg.EngineTorqueDriverRequest = *reinterpret_cast<std::decay<decltype(msg.EngineTorqueDriverRequest)>::type*>(&EngineTorqueDriverRequest.signal);
        msg.EngineTorqueDriverRequest = msg.EngineTorqueDriverRequest * factor + offset;
        factor = EngineTorqueLoss.factor;
        offset = EngineTorqueLoss.offset;
        msg.EngineTorqueLoss = *reinterpret_cast<std::decay<decltype(msg.EngineTorqueLoss)>::type*>(&EngineTorqueLoss.signal);
        msg.EngineTorqueLoss = msg.EngineTorqueLoss * factor + offset;
        factor = SSMStatus.factor;
        offset = SSMStatus.offset;
        msg.SSMStatus = *reinterpret_cast<std::decay<decltype(msg.SSMStatus)>::type*>(&SSMStatus.signal);
        msg.SSMStatus = msg.SSMStatus * factor + offset;
        factor = EMS_3_MessageCounter.factor;
        offset = EMS_3_MessageCounter.offset;
        msg.EMS_3_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.EMS_3_MessageCounter)>::type*>(&EMS_3_MessageCounter.signal);
        msg.EMS_3_MessageCounter = msg.EMS_3_MessageCounter * factor + offset;
        factor = EMS_3_Checksum.factor;
        offset = EMS_3_Checksum.offset;
        msg.EMS_3_Checksum = *reinterpret_cast<std::decay<decltype(msg.EMS_3_Checksum)>::type*>(&EMS_3_Checksum.signal);
        msg.EMS_3_Checksum = msg.EMS_3_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_EMS_3_MSG can_struct;
        CanParser2CanStruct_HCU_EMS_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_EMS_3_MSGMsg>();
        Struct2Proto_HCU_EMS_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_ems_3") != nullptr) {
            DFHLOG_I("hcu_ems_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_ems_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_ems_3");
            return false;
         }
    }
};

struct EMS_6_Parser {
    SignalParser ECGPOvrd;

    SignalParser ECGPOvrdInvalidData;

    SignalParser EMS6_MessageCounter;

    SignalParser EMS6_CRC;

    EMS_6_Parser() {
        ECGPOvrd = CanConfiguration::Instance().SignalParsers()["ECGPOvrd"];
        ECGPOvrdInvalidData = CanConfiguration::Instance().SignalParsers()["ECGPOvrdInvalidData"];
        EMS6_MessageCounter = CanConfiguration::Instance().SignalParsers()["EMS6_MessageCounter"];
        EMS6_CRC = CanConfiguration::Instance().SignalParsers()["EMS6_CRC"];
    }

    void Parser(uint8_t* payload){
        ECGPOvrd.Parser(payload);
        ECGPOvrdInvalidData.Parser(payload);
        EMS6_MessageCounter.Parser(payload);
        EMS6_CRC.Parser(payload);
    }

    void CanParser2CanStruct_EMS_6_MSG(EMS_6_MSG& msg) {
        double factor;
        double offset;
        factor = ECGPOvrd.factor;
        offset = ECGPOvrd.offset;
        msg.ECGPOvrd = *reinterpret_cast<std::decay<decltype(msg.ECGPOvrd)>::type*>(&ECGPOvrd.signal);
        msg.ECGPOvrd = msg.ECGPOvrd * factor + offset;
        factor = ECGPOvrdInvalidData.factor;
        offset = ECGPOvrdInvalidData.offset;
        msg.ECGPOvrdInvalidData = *reinterpret_cast<std::decay<decltype(msg.ECGPOvrdInvalidData)>::type*>(&ECGPOvrdInvalidData.signal);
        msg.ECGPOvrdInvalidData = msg.ECGPOvrdInvalidData * factor + offset;
        factor = EMS6_MessageCounter.factor;
        offset = EMS6_MessageCounter.offset;
        msg.EMS6_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.EMS6_MessageCounter)>::type*>(&EMS6_MessageCounter.signal);
        msg.EMS6_MessageCounter = msg.EMS6_MessageCounter * factor + offset;
        factor = EMS6_CRC.factor;
        offset = EMS6_CRC.offset;
        msg.EMS6_CRC = *reinterpret_cast<std::decay<decltype(msg.EMS6_CRC)>::type*>(&EMS6_CRC.signal);
        msg.EMS6_CRC = msg.EMS6_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EMS_6_MSG can_struct;
        CanParser2CanStruct_EMS_6_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EMS_6_MSGMsg>();
        Struct2Proto_EMS_6_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ems_6") != nullptr) {
            DFHLOG_I("ems_6");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ems_6")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ems_6");
            return false;
         }
    }
};

struct EMS_1_G_Parser {
    SignalParser EngineSts;

    EMS_1_G_Parser() {
        EngineSts = CanConfiguration::Instance().SignalParsers()["EngineSts"];
    }

    void Parser(uint8_t* payload){
        EngineSts.Parser(payload);
    }

    void CanParser2CanStruct_EMS_1_G_MSG(EMS_1_G_MSG& msg) {
        double factor;
        double offset;
        factor = EngineSts.factor;
        offset = EngineSts.offset;
        msg.EngineSts = *reinterpret_cast<std::decay<decltype(msg.EngineSts)>::type*>(&EngineSts.signal);
        msg.EngineSts = msg.EngineSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EMS_1_G_MSG can_struct;
        CanParser2CanStruct_EMS_1_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EMS_1_G_MSGMsg>();
        Struct2Proto_EMS_1_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ems_1_g") != nullptr) {
            DFHLOG_I("ems_1_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ems_1_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ems_1_g");
            return false;
         }
    }
};

struct HCU_EMS_2_G_Parser {
    SignalParser LimitSpeedSts;

    SignalParser GasPedalPosition;

    SignalParser GasPedalPositionInvalidData;

    SignalParser EMS_2_G_MessageCounter;

    SignalParser EMS_2_G_CRC;

    HCU_EMS_2_G_Parser() {
        LimitSpeedSts = CanConfiguration::Instance().SignalParsers()["LimitSpeedSts"];
        GasPedalPosition = CanConfiguration::Instance().SignalParsers()["GasPedalPosition"];
        GasPedalPositionInvalidData = CanConfiguration::Instance().SignalParsers()["GasPedalPositionInvalidData"];
        EMS_2_G_MessageCounter = CanConfiguration::Instance().SignalParsers()["EMS_2_G_MessageCounter"];
        EMS_2_G_CRC = CanConfiguration::Instance().SignalParsers()["EMS_2_G_CRC"];
    }

    void Parser(uint8_t* payload){
        LimitSpeedSts.Parser(payload);
        GasPedalPosition.Parser(payload);
        GasPedalPositionInvalidData.Parser(payload);
        EMS_2_G_MessageCounter.Parser(payload);
        EMS_2_G_CRC.Parser(payload);
    }

    void CanParser2CanStruct_HCU_EMS_2_G_MSG(HCU_EMS_2_G_MSG& msg) {
        double factor;
        double offset;
        factor = LimitSpeedSts.factor;
        offset = LimitSpeedSts.offset;
        msg.LimitSpeedSts = *reinterpret_cast<std::decay<decltype(msg.LimitSpeedSts)>::type*>(&LimitSpeedSts.signal);
        msg.LimitSpeedSts = msg.LimitSpeedSts * factor + offset;
        factor = GasPedalPosition.factor;
        offset = GasPedalPosition.offset;
        msg.GasPedalPosition = *reinterpret_cast<std::decay<decltype(msg.GasPedalPosition)>::type*>(&GasPedalPosition.signal);
        msg.GasPedalPosition = msg.GasPedalPosition * factor + offset;
        factor = GasPedalPositionInvalidData.factor;
        offset = GasPedalPositionInvalidData.offset;
        msg.GasPedalPositionInvalidData = *reinterpret_cast<std::decay<decltype(msg.GasPedalPositionInvalidData)>::type*>(&GasPedalPositionInvalidData.signal);
        msg.GasPedalPositionInvalidData = msg.GasPedalPositionInvalidData * factor + offset;
        factor = EMS_2_G_MessageCounter.factor;
        offset = EMS_2_G_MessageCounter.offset;
        msg.EMS_2_G_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.EMS_2_G_MessageCounter)>::type*>(&EMS_2_G_MessageCounter.signal);
        msg.EMS_2_G_MessageCounter = msg.EMS_2_G_MessageCounter * factor + offset;
        factor = EMS_2_G_CRC.factor;
        offset = EMS_2_G_CRC.offset;
        msg.EMS_2_G_CRC = *reinterpret_cast<std::decay<decltype(msg.EMS_2_G_CRC)>::type*>(&EMS_2_G_CRC.signal);
        msg.EMS_2_G_CRC = msg.EMS_2_G_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_EMS_2_G_MSG can_struct;
        CanParser2CanStruct_HCU_EMS_2_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_EMS_2_G_MSGMsg>();
        Struct2Proto_HCU_EMS_2_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_ems_2_g") != nullptr) {
            DFHLOG_I("hcu_ems_2_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_ems_2_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_ems_2_g");
            return false;
         }
    }
};

struct EPB_G_Parser {
    SignalParser EPBErrorStatus;

    SignalParser EPBStatus;

    SignalParser RWUActive;

    EPB_G_Parser() {
        EPBErrorStatus = CanConfiguration::Instance().SignalParsers()["EPBErrorStatus"];
        EPBStatus = CanConfiguration::Instance().SignalParsers()["EPBStatus"];
        RWUActive = CanConfiguration::Instance().SignalParsers()["RWUActive"];
    }

    void Parser(uint8_t* payload){
        EPBErrorStatus.Parser(payload);
        EPBStatus.Parser(payload);
        RWUActive.Parser(payload);
    }

    void CanParser2CanStruct_EPB_G_MSG(EPB_G_MSG& msg) {
        double factor;
        double offset;
        factor = EPBErrorStatus.factor;
        offset = EPBErrorStatus.offset;
        msg.EPBErrorStatus = *reinterpret_cast<std::decay<decltype(msg.EPBErrorStatus)>::type*>(&EPBErrorStatus.signal);
        msg.EPBErrorStatus = msg.EPBErrorStatus * factor + offset;
        factor = EPBStatus.factor;
        offset = EPBStatus.offset;
        msg.EPBStatus = *reinterpret_cast<std::decay<decltype(msg.EPBStatus)>::type*>(&EPBStatus.signal);
        msg.EPBStatus = msg.EPBStatus * factor + offset;
        factor = RWUActive.factor;
        offset = RWUActive.offset;
        msg.RWUActive = *reinterpret_cast<std::decay<decltype(msg.RWUActive)>::type*>(&RWUActive.signal);
        msg.RWUActive = msg.RWUActive * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPB_G_MSG can_struct;
        CanParser2CanStruct_EPB_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPB_G_MSGMsg>();
        Struct2Proto_EPB_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("epb_g") != nullptr) {
            DFHLOG_I("epb_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("epb_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port epb_g");
            return false;
         }
    }
};

struct EPS_1_Parser {
    SignalParser EPSFailSts;

    SignalParser EPSSteeringAngleCalibrationSts;

    EPS_1_Parser() {
        EPSFailSts = CanConfiguration::Instance().SignalParsers()["EPSFailSts"];
        EPSSteeringAngleCalibrationSts = CanConfiguration::Instance().SignalParsers()["EPSSteeringAngleCalibrationSts"];
    }

    void Parser(uint8_t* payload){
        EPSFailSts.Parser(payload);
        EPSSteeringAngleCalibrationSts.Parser(payload);
    }

    void CanParser2CanStruct_EPS_1_MSG(EPS_1_MSG& msg) {
        double factor;
        double offset;
        factor = EPSFailSts.factor;
        offset = EPSFailSts.offset;
        msg.EPSFailSts = *reinterpret_cast<std::decay<decltype(msg.EPSFailSts)>::type*>(&EPSFailSts.signal);
        msg.EPSFailSts = msg.EPSFailSts * factor + offset;
        factor = EPSSteeringAngleCalibrationSts.factor;
        offset = EPSSteeringAngleCalibrationSts.offset;
        msg.EPSSteeringAngleCalibrationSts = *reinterpret_cast<std::decay<decltype(msg.EPSSteeringAngleCalibrationSts)>::type*>(&EPSSteeringAngleCalibrationSts.signal);
        msg.EPSSteeringAngleCalibrationSts = msg.EPSSteeringAngleCalibrationSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPS_1_MSG can_struct;
        CanParser2CanStruct_EPS_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPS_1_MSGMsg>();
        Struct2Proto_EPS_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("eps_1") != nullptr) {
            DFHLOG_I("eps_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("eps_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port eps_1");
            return false;
         }
    }
};

struct EPS_2_Parser {
    SignalParser TorsionBarTorque;

    SignalParser TorsionBarTorqueDir;

    SignalParser TosionBarTorqueValid;

    SignalParser EpsControlStatus;

    SignalParser EPS_APA_SteeringAngleInvalid;

    SignalParser EPS_APA_SteeringWheelAngleRes;

    SignalParser EPS_APA_CurrentSystemStatus;

    SignalParser EPS_APA_FaultStatus;

    SignalParser EPS_2_Message_Counter;

    SignalParser EPS_2_CRC;

    EPS_2_Parser() {
        TorsionBarTorque = CanConfiguration::Instance().SignalParsers()["TorsionBarTorque"];
        TorsionBarTorqueDir = CanConfiguration::Instance().SignalParsers()["TorsionBarTorqueDir"];
        TosionBarTorqueValid = CanConfiguration::Instance().SignalParsers()["TosionBarTorqueValid"];
        EpsControlStatus = CanConfiguration::Instance().SignalParsers()["EpsControlStatus"];
        EPS_APA_SteeringAngleInvalid = CanConfiguration::Instance().SignalParsers()["EPS_APA_SteeringAngleInvalid"];
        EPS_APA_SteeringWheelAngleRes = CanConfiguration::Instance().SignalParsers()["EPS_APA_SteeringWheelAngleRes"];
        EPS_APA_CurrentSystemStatus = CanConfiguration::Instance().SignalParsers()["EPS_APA_CurrentSystemStatus"];
        EPS_APA_FaultStatus = CanConfiguration::Instance().SignalParsers()["EPS_APA_FaultStatus"];
        EPS_2_Message_Counter = CanConfiguration::Instance().SignalParsers()["EPS_2_Message_Counter"];
        EPS_2_CRC = CanConfiguration::Instance().SignalParsers()["EPS_2_CRC"];
    }

    void Parser(uint8_t* payload){
        TorsionBarTorque.Parser(payload);
        TorsionBarTorqueDir.Parser(payload);
        TosionBarTorqueValid.Parser(payload);
        EpsControlStatus.Parser(payload);
        EPS_APA_SteeringAngleInvalid.Parser(payload);
        EPS_APA_SteeringWheelAngleRes.Parser(payload);
        EPS_APA_CurrentSystemStatus.Parser(payload);
        EPS_APA_FaultStatus.Parser(payload);
        EPS_2_Message_Counter.Parser(payload);
        EPS_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_EPS_2_MSG(EPS_2_MSG& msg) {
        double factor;
        double offset;
        factor = TorsionBarTorque.factor;
        offset = TorsionBarTorque.offset;
        msg.TorsionBarTorque = *reinterpret_cast<std::decay<decltype(msg.TorsionBarTorque)>::type*>(&TorsionBarTorque.signal);
        msg.TorsionBarTorque = msg.TorsionBarTorque * factor + offset;
        factor = TorsionBarTorqueDir.factor;
        offset = TorsionBarTorqueDir.offset;
        msg.TorsionBarTorqueDir = *reinterpret_cast<std::decay<decltype(msg.TorsionBarTorqueDir)>::type*>(&TorsionBarTorqueDir.signal);
        msg.TorsionBarTorqueDir = msg.TorsionBarTorqueDir * factor + offset;
        factor = TosionBarTorqueValid.factor;
        offset = TosionBarTorqueValid.offset;
        msg.TosionBarTorqueValid = *reinterpret_cast<std::decay<decltype(msg.TosionBarTorqueValid)>::type*>(&TosionBarTorqueValid.signal);
        msg.TosionBarTorqueValid = msg.TosionBarTorqueValid * factor + offset;
        factor = EpsControlStatus.factor;
        offset = EpsControlStatus.offset;
        msg.EpsControlStatus = *reinterpret_cast<std::decay<decltype(msg.EpsControlStatus)>::type*>(&EpsControlStatus.signal);
        msg.EpsControlStatus = msg.EpsControlStatus * factor + offset;
        factor = EPS_APA_SteeringAngleInvalid.factor;
        offset = EPS_APA_SteeringAngleInvalid.offset;
        msg.EPS_APA_SteeringAngleInvalid = *reinterpret_cast<std::decay<decltype(msg.EPS_APA_SteeringAngleInvalid)>::type*>(&EPS_APA_SteeringAngleInvalid.signal);
        msg.EPS_APA_SteeringAngleInvalid = msg.EPS_APA_SteeringAngleInvalid * factor + offset;
        factor = EPS_APA_SteeringWheelAngleRes.factor;
        offset = EPS_APA_SteeringWheelAngleRes.offset;
        msg.EPS_APA_SteeringWheelAngleRes = *reinterpret_cast<std::decay<decltype(msg.EPS_APA_SteeringWheelAngleRes)>::type*>(&EPS_APA_SteeringWheelAngleRes.signal);
        msg.EPS_APA_SteeringWheelAngleRes = msg.EPS_APA_SteeringWheelAngleRes * factor + offset;
        factor = EPS_APA_CurrentSystemStatus.factor;
        offset = EPS_APA_CurrentSystemStatus.offset;
        msg.EPS_APA_CurrentSystemStatus = *reinterpret_cast<std::decay<decltype(msg.EPS_APA_CurrentSystemStatus)>::type*>(&EPS_APA_CurrentSystemStatus.signal);
        msg.EPS_APA_CurrentSystemStatus = msg.EPS_APA_CurrentSystemStatus * factor + offset;
        factor = EPS_APA_FaultStatus.factor;
        offset = EPS_APA_FaultStatus.offset;
        msg.EPS_APA_FaultStatus = *reinterpret_cast<std::decay<decltype(msg.EPS_APA_FaultStatus)>::type*>(&EPS_APA_FaultStatus.signal);
        msg.EPS_APA_FaultStatus = msg.EPS_APA_FaultStatus * factor + offset;
        factor = EPS_2_Message_Counter.factor;
        offset = EPS_2_Message_Counter.offset;
        msg.EPS_2_Message_Counter = *reinterpret_cast<std::decay<decltype(msg.EPS_2_Message_Counter)>::type*>(&EPS_2_Message_Counter.signal);
        msg.EPS_2_Message_Counter = msg.EPS_2_Message_Counter * factor + offset;
        factor = EPS_2_CRC.factor;
        offset = EPS_2_CRC.offset;
        msg.EPS_2_CRC = *reinterpret_cast<std::decay<decltype(msg.EPS_2_CRC)>::type*>(&EPS_2_CRC.signal);
        msg.EPS_2_CRC = msg.EPS_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPS_2_MSG can_struct;
        CanParser2CanStruct_EPS_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPS_2_MSGMsg>();
        Struct2Proto_EPS_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("eps_2") != nullptr) {
            DFHLOG_I("eps_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("eps_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port eps_2");
            return false;
         }
    }
};

struct EPS_3_Parser {
    SignalParser EPS_3_StrngWhlAg;

    SignalParser EPS_3_StrngWhlAgValid;

    SignalParser EPS_3_StrngAgSpdValidData;

    SignalParser EPS_3_StrngAgSpd;

    SignalParser EPS_3_AgFailr;

    SignalParser EPS_3_Message_Counter;

    SignalParser EPS_3_CRC;

    EPS_3_Parser() {
        EPS_3_StrngWhlAg = CanConfiguration::Instance().SignalParsers()["EPS_3_StrngWhlAg"];
        EPS_3_StrngWhlAgValid = CanConfiguration::Instance().SignalParsers()["EPS_3_StrngWhlAgValid"];
        EPS_3_StrngAgSpdValidData = CanConfiguration::Instance().SignalParsers()["EPS_3_StrngAgSpdValidData"];
        EPS_3_StrngAgSpd = CanConfiguration::Instance().SignalParsers()["EPS_3_StrngAgSpd"];
        EPS_3_AgFailr = CanConfiguration::Instance().SignalParsers()["EPS_3_AgFailr"];
        EPS_3_Message_Counter = CanConfiguration::Instance().SignalParsers()["EPS_3_Message_Counter"];
        EPS_3_CRC = CanConfiguration::Instance().SignalParsers()["EPS_3_CRC"];
    }

    void Parser(uint8_t* payload){
        EPS_3_StrngWhlAg.Parser(payload);
        EPS_3_StrngWhlAgValid.Parser(payload);
        EPS_3_StrngAgSpdValidData.Parser(payload);
        EPS_3_StrngAgSpd.Parser(payload);
        EPS_3_AgFailr.Parser(payload);
        EPS_3_Message_Counter.Parser(payload);
        EPS_3_CRC.Parser(payload);
    }

    void CanParser2CanStruct_EPS_3_MSG(EPS_3_MSG& msg) {
        double factor;
        double offset;
        factor = EPS_3_StrngWhlAg.factor;
        offset = EPS_3_StrngWhlAg.offset;
        msg.EPS_3_StrngWhlAg = *reinterpret_cast<std::decay<decltype(msg.EPS_3_StrngWhlAg)>::type*>(&EPS_3_StrngWhlAg.signal);
        msg.EPS_3_StrngWhlAg = msg.EPS_3_StrngWhlAg * factor + offset;
        factor = EPS_3_StrngWhlAgValid.factor;
        offset = EPS_3_StrngWhlAgValid.offset;
        msg.EPS_3_StrngWhlAgValid = *reinterpret_cast<std::decay<decltype(msg.EPS_3_StrngWhlAgValid)>::type*>(&EPS_3_StrngWhlAgValid.signal);
        msg.EPS_3_StrngWhlAgValid = msg.EPS_3_StrngWhlAgValid * factor + offset;
        factor = EPS_3_StrngAgSpdValidData.factor;
        offset = EPS_3_StrngAgSpdValidData.offset;
        msg.EPS_3_StrngAgSpdValidData = *reinterpret_cast<std::decay<decltype(msg.EPS_3_StrngAgSpdValidData)>::type*>(&EPS_3_StrngAgSpdValidData.signal);
        msg.EPS_3_StrngAgSpdValidData = msg.EPS_3_StrngAgSpdValidData * factor + offset;
        factor = EPS_3_StrngAgSpd.factor;
        offset = EPS_3_StrngAgSpd.offset;
        msg.EPS_3_StrngAgSpd = *reinterpret_cast<std::decay<decltype(msg.EPS_3_StrngAgSpd)>::type*>(&EPS_3_StrngAgSpd.signal);
        msg.EPS_3_StrngAgSpd = msg.EPS_3_StrngAgSpd * factor + offset;
        factor = EPS_3_AgFailr.factor;
        offset = EPS_3_AgFailr.offset;
        msg.EPS_3_AgFailr = *reinterpret_cast<std::decay<decltype(msg.EPS_3_AgFailr)>::type*>(&EPS_3_AgFailr.signal);
        msg.EPS_3_AgFailr = msg.EPS_3_AgFailr * factor + offset;
        factor = EPS_3_Message_Counter.factor;
        offset = EPS_3_Message_Counter.offset;
        msg.EPS_3_Message_Counter = *reinterpret_cast<std::decay<decltype(msg.EPS_3_Message_Counter)>::type*>(&EPS_3_Message_Counter.signal);
        msg.EPS_3_Message_Counter = msg.EPS_3_Message_Counter * factor + offset;
        factor = EPS_3_CRC.factor;
        offset = EPS_3_CRC.offset;
        msg.EPS_3_CRC = *reinterpret_cast<std::decay<decltype(msg.EPS_3_CRC)>::type*>(&EPS_3_CRC.signal);
        msg.EPS_3_CRC = msg.EPS_3_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPS_3_MSG can_struct;
        CanParser2CanStruct_EPS_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPS_3_MSGMsg>();
        Struct2Proto_EPS_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("eps_3") != nullptr) {
            DFHLOG_I("eps_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("eps_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port eps_3");
            return false;
         }
    }
};

struct EPS_4_Parser {
    SignalParser EPS_4_LoASts;

    SignalParser EPS_4_LatDrvgAvlForLvl;

    SignalParser EPS_4_HptcVibSrvAvl;

    SignalParser EPS_4_AgCtrlLimActvd;

    SignalParser EPS_4_MotorTorque;

    SignalParser EPS_4_StrngWhlAgResActive;

    SignalParser EPS_4_PSCMActRPCTrqValid;

    SignalParser EPS_4_PSCMActRPCTrq;

    SignalParser EPS_4_Message_Counter;

    SignalParser EPS_4_CRC;

    EPS_4_Parser() {
        EPS_4_LoASts = CanConfiguration::Instance().SignalParsers()["EPS_4_LoASts"];
        EPS_4_LatDrvgAvlForLvl = CanConfiguration::Instance().SignalParsers()["EPS_4_LatDrvgAvlForLvl"];
        EPS_4_HptcVibSrvAvl = CanConfiguration::Instance().SignalParsers()["EPS_4_HptcVibSrvAvl"];
        EPS_4_AgCtrlLimActvd = CanConfiguration::Instance().SignalParsers()["EPS_4_AgCtrlLimActvd"];
        EPS_4_MotorTorque = CanConfiguration::Instance().SignalParsers()["EPS_4_MotorTorque"];
        EPS_4_StrngWhlAgResActive = CanConfiguration::Instance().SignalParsers()["EPS_4_StrngWhlAgResActive"];
        EPS_4_PSCMActRPCTrqValid = CanConfiguration::Instance().SignalParsers()["EPS_4_PSCMActRPCTrqValid"];
        EPS_4_PSCMActRPCTrq = CanConfiguration::Instance().SignalParsers()["EPS_4_PSCMActRPCTrq"];
        EPS_4_Message_Counter = CanConfiguration::Instance().SignalParsers()["EPS_4_Message_Counter"];
        EPS_4_CRC = CanConfiguration::Instance().SignalParsers()["EPS_4_CRC"];
    }

    void Parser(uint8_t* payload){
        EPS_4_LoASts.Parser(payload);
        EPS_4_LatDrvgAvlForLvl.Parser(payload);
        EPS_4_HptcVibSrvAvl.Parser(payload);
        EPS_4_AgCtrlLimActvd.Parser(payload);
        EPS_4_MotorTorque.Parser(payload);
        EPS_4_StrngWhlAgResActive.Parser(payload);
        EPS_4_PSCMActRPCTrqValid.Parser(payload);
        EPS_4_PSCMActRPCTrq.Parser(payload);
        EPS_4_Message_Counter.Parser(payload);
        EPS_4_CRC.Parser(payload);
    }

    void CanParser2CanStruct_EPS_4_MSG(EPS_4_MSG& msg) {
        double factor;
        double offset;
        factor = EPS_4_LoASts.factor;
        offset = EPS_4_LoASts.offset;
        msg.EPS_4_LoASts = *reinterpret_cast<std::decay<decltype(msg.EPS_4_LoASts)>::type*>(&EPS_4_LoASts.signal);
        msg.EPS_4_LoASts = msg.EPS_4_LoASts * factor + offset;
        factor = EPS_4_LatDrvgAvlForLvl.factor;
        offset = EPS_4_LatDrvgAvlForLvl.offset;
        msg.EPS_4_LatDrvgAvlForLvl = *reinterpret_cast<std::decay<decltype(msg.EPS_4_LatDrvgAvlForLvl)>::type*>(&EPS_4_LatDrvgAvlForLvl.signal);
        msg.EPS_4_LatDrvgAvlForLvl = msg.EPS_4_LatDrvgAvlForLvl * factor + offset;
        factor = EPS_4_HptcVibSrvAvl.factor;
        offset = EPS_4_HptcVibSrvAvl.offset;
        msg.EPS_4_HptcVibSrvAvl = *reinterpret_cast<std::decay<decltype(msg.EPS_4_HptcVibSrvAvl)>::type*>(&EPS_4_HptcVibSrvAvl.signal);
        msg.EPS_4_HptcVibSrvAvl = msg.EPS_4_HptcVibSrvAvl * factor + offset;
        factor = EPS_4_AgCtrlLimActvd.factor;
        offset = EPS_4_AgCtrlLimActvd.offset;
        msg.EPS_4_AgCtrlLimActvd = *reinterpret_cast<std::decay<decltype(msg.EPS_4_AgCtrlLimActvd)>::type*>(&EPS_4_AgCtrlLimActvd.signal);
        msg.EPS_4_AgCtrlLimActvd = msg.EPS_4_AgCtrlLimActvd * factor + offset;
        factor = EPS_4_MotorTorque.factor;
        offset = EPS_4_MotorTorque.offset;
        msg.EPS_4_MotorTorque = *reinterpret_cast<std::decay<decltype(msg.EPS_4_MotorTorque)>::type*>(&EPS_4_MotorTorque.signal);
        msg.EPS_4_MotorTorque = msg.EPS_4_MotorTorque * factor + offset;
        factor = EPS_4_StrngWhlAgResActive.factor;
        offset = EPS_4_StrngWhlAgResActive.offset;
        msg.EPS_4_StrngWhlAgResActive = *reinterpret_cast<std::decay<decltype(msg.EPS_4_StrngWhlAgResActive)>::type*>(&EPS_4_StrngWhlAgResActive.signal);
        msg.EPS_4_StrngWhlAgResActive = msg.EPS_4_StrngWhlAgResActive * factor + offset;
        factor = EPS_4_PSCMActRPCTrqValid.factor;
        offset = EPS_4_PSCMActRPCTrqValid.offset;
        msg.EPS_4_PSCMActRPCTrqValid = *reinterpret_cast<std::decay<decltype(msg.EPS_4_PSCMActRPCTrqValid)>::type*>(&EPS_4_PSCMActRPCTrqValid.signal);
        msg.EPS_4_PSCMActRPCTrqValid = msg.EPS_4_PSCMActRPCTrqValid * factor + offset;
        factor = EPS_4_PSCMActRPCTrq.factor;
        offset = EPS_4_PSCMActRPCTrq.offset;
        msg.EPS_4_PSCMActRPCTrq = *reinterpret_cast<std::decay<decltype(msg.EPS_4_PSCMActRPCTrq)>::type*>(&EPS_4_PSCMActRPCTrq.signal);
        msg.EPS_4_PSCMActRPCTrq = msg.EPS_4_PSCMActRPCTrq * factor + offset;
        factor = EPS_4_Message_Counter.factor;
        offset = EPS_4_Message_Counter.offset;
        msg.EPS_4_Message_Counter = *reinterpret_cast<std::decay<decltype(msg.EPS_4_Message_Counter)>::type*>(&EPS_4_Message_Counter.signal);
        msg.EPS_4_Message_Counter = msg.EPS_4_Message_Counter * factor + offset;
        factor = EPS_4_CRC.factor;
        offset = EPS_4_CRC.offset;
        msg.EPS_4_CRC = *reinterpret_cast<std::decay<decltype(msg.EPS_4_CRC)>::type*>(&EPS_4_CRC.signal);
        msg.EPS_4_CRC = msg.EPS_4_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPS_4_MSG can_struct;
        CanParser2CanStruct_EPS_4_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPS_4_MSGMsg>();
        Struct2Proto_EPS_4_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("eps_4") != nullptr) {
            DFHLOG_I("eps_4");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("eps_4")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port eps_4");
            return false;
         }
    }
};

struct EPB_State_R_Parser {
    SignalParser EPB_State_R_CRC1;

    SignalParser EPB_State_R_RollgCntr1;

    SignalParser EPB_EPBAvl_St;

    SignalParser EPBStatus;

    SignalParser EPB_State_R_CRC2;

    SignalParser EPB_State_R_RollgCntr2;

    SignalParser EPB_ActrSt_R;

    SignalParser EPB_FltLvl_R;

    SignalParser EPB_State_L_CRC1;

    SignalParser EPB_State_L_RollgCntr1;

    SignalParser EPB_ActrSt_L;

    SignalParser EPB_FltLvl_L;

    EPB_State_R_Parser() {
        EPB_State_R_CRC1 = CanConfiguration::Instance().SignalParsers()["EPB_State_R_CRC1"];
        EPB_State_R_RollgCntr1 = CanConfiguration::Instance().SignalParsers()["EPB_State_R_RollgCntr1"];
        EPB_EPBAvl_St = CanConfiguration::Instance().SignalParsers()["EPB_EPBAvl_St"];
        EPBStatus = CanConfiguration::Instance().SignalParsers()["EPBStatus"];
        EPB_State_R_CRC2 = CanConfiguration::Instance().SignalParsers()["EPB_State_R_CRC2"];
        EPB_State_R_RollgCntr2 = CanConfiguration::Instance().SignalParsers()["EPB_State_R_RollgCntr2"];
        EPB_ActrSt_R = CanConfiguration::Instance().SignalParsers()["EPB_ActrSt_R"];
        EPB_FltLvl_R = CanConfiguration::Instance().SignalParsers()["EPB_FltLvl_R"];
        EPB_State_L_CRC1 = CanConfiguration::Instance().SignalParsers()["EPB_State_L_CRC1"];
        EPB_State_L_RollgCntr1 = CanConfiguration::Instance().SignalParsers()["EPB_State_L_RollgCntr1"];
        EPB_ActrSt_L = CanConfiguration::Instance().SignalParsers()["EPB_ActrSt_L"];
        EPB_FltLvl_L = CanConfiguration::Instance().SignalParsers()["EPB_FltLvl_L"];
    }

    void Parser(uint8_t* payload){
        EPB_State_R_CRC1.Parser(payload);
        EPB_State_R_RollgCntr1.Parser(payload);
        EPB_EPBAvl_St.Parser(payload);
        EPBStatus.Parser(payload);
        EPB_State_R_CRC2.Parser(payload);
        EPB_State_R_RollgCntr2.Parser(payload);
        EPB_ActrSt_R.Parser(payload);
        EPB_FltLvl_R.Parser(payload);
        EPB_State_L_CRC1.Parser(payload);
        EPB_State_L_RollgCntr1.Parser(payload);
        EPB_ActrSt_L.Parser(payload);
        EPB_FltLvl_L.Parser(payload);
    }

    void CanParser2CanStruct_EPB_State_R_MSG(EPB_State_R_MSG& msg) {
        double factor;
        double offset;
        factor = EPB_State_R_CRC1.factor;
        offset = EPB_State_R_CRC1.offset;
        msg.EPB_State_R_CRC1 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_R_CRC1)>::type*>(&EPB_State_R_CRC1.signal);
        msg.EPB_State_R_CRC1 = msg.EPB_State_R_CRC1 * factor + offset;
        factor = EPB_State_R_RollgCntr1.factor;
        offset = EPB_State_R_RollgCntr1.offset;
        msg.EPB_State_R_RollgCntr1 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_R_RollgCntr1)>::type*>(&EPB_State_R_RollgCntr1.signal);
        msg.EPB_State_R_RollgCntr1 = msg.EPB_State_R_RollgCntr1 * factor + offset;
        factor = EPB_EPBAvl_St.factor;
        offset = EPB_EPBAvl_St.offset;
        msg.EPB_EPBAvl_St = *reinterpret_cast<std::decay<decltype(msg.EPB_EPBAvl_St)>::type*>(&EPB_EPBAvl_St.signal);
        msg.EPB_EPBAvl_St = msg.EPB_EPBAvl_St * factor + offset;
        factor = EPBStatus.factor;
        offset = EPBStatus.offset;
        msg.EPBStatus = *reinterpret_cast<std::decay<decltype(msg.EPBStatus)>::type*>(&EPBStatus.signal);
        msg.EPBStatus = msg.EPBStatus * factor + offset;
        factor = EPB_State_R_CRC2.factor;
        offset = EPB_State_R_CRC2.offset;
        msg.EPB_State_R_CRC2 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_R_CRC2)>::type*>(&EPB_State_R_CRC2.signal);
        msg.EPB_State_R_CRC2 = msg.EPB_State_R_CRC2 * factor + offset;
        factor = EPB_State_R_RollgCntr2.factor;
        offset = EPB_State_R_RollgCntr2.offset;
        msg.EPB_State_R_RollgCntr2 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_R_RollgCntr2)>::type*>(&EPB_State_R_RollgCntr2.signal);
        msg.EPB_State_R_RollgCntr2 = msg.EPB_State_R_RollgCntr2 * factor + offset;
        factor = EPB_ActrSt_R.factor;
        offset = EPB_ActrSt_R.offset;
        msg.EPB_ActrSt_R = *reinterpret_cast<std::decay<decltype(msg.EPB_ActrSt_R)>::type*>(&EPB_ActrSt_R.signal);
        msg.EPB_ActrSt_R = msg.EPB_ActrSt_R * factor + offset;
        factor = EPB_FltLvl_R.factor;
        offset = EPB_FltLvl_R.offset;
        msg.EPB_FltLvl_R = *reinterpret_cast<std::decay<decltype(msg.EPB_FltLvl_R)>::type*>(&EPB_FltLvl_R.signal);
        msg.EPB_FltLvl_R = msg.EPB_FltLvl_R * factor + offset;
        factor = EPB_State_L_CRC1.factor;
        offset = EPB_State_L_CRC1.offset;
        msg.EPB_State_L_CRC1 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_L_CRC1)>::type*>(&EPB_State_L_CRC1.signal);
        msg.EPB_State_L_CRC1 = msg.EPB_State_L_CRC1 * factor + offset;
        factor = EPB_State_L_RollgCntr1.factor;
        offset = EPB_State_L_RollgCntr1.offset;
        msg.EPB_State_L_RollgCntr1 = *reinterpret_cast<std::decay<decltype(msg.EPB_State_L_RollgCntr1)>::type*>(&EPB_State_L_RollgCntr1.signal);
        msg.EPB_State_L_RollgCntr1 = msg.EPB_State_L_RollgCntr1 * factor + offset;
        factor = EPB_ActrSt_L.factor;
        offset = EPB_ActrSt_L.offset;
        msg.EPB_ActrSt_L = *reinterpret_cast<std::decay<decltype(msg.EPB_ActrSt_L)>::type*>(&EPB_ActrSt_L.signal);
        msg.EPB_ActrSt_L = msg.EPB_ActrSt_L * factor + offset;
        factor = EPB_FltLvl_L.factor;
        offset = EPB_FltLvl_L.offset;
        msg.EPB_FltLvl_L = *reinterpret_cast<std::decay<decltype(msg.EPB_FltLvl_L)>::type*>(&EPB_FltLvl_L.signal);
        msg.EPB_FltLvl_L = msg.EPB_FltLvl_L * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        EPB_State_R_MSG can_struct;
        CanParser2CanStruct_EPB_State_R_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::EPB_State_R_MSGMsg>();
        Struct2Proto_EPB_State_R_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("epb_state_r") != nullptr) {
            DFHLOG_I("epb_state_r");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("epb_state_r")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port epb_state_r");
            return false;
         }
    }
};

struct HCU_6_Parser {
    SignalParser HCU_6_MaxTorqueWheel;

    SignalParser HCU_6_MinTorqueWheel;

    SignalParser HCU_6_ECGPOvrd;

    SignalParser HCU_6_ECGPOvrdInvalidData;

    SignalParser APA_HCU_available;

    SignalParser APA_HCU_DriverIntervention;

    SignalParser HCU_6_MessageCounter;

    SignalParser HCU_6_CRC;

    HCU_6_Parser() {
        HCU_6_MaxTorqueWheel = CanConfiguration::Instance().SignalParsers()["HCU_6_MaxTorqueWheel"];
        HCU_6_MinTorqueWheel = CanConfiguration::Instance().SignalParsers()["HCU_6_MinTorqueWheel"];
        HCU_6_ECGPOvrd = CanConfiguration::Instance().SignalParsers()["HCU_6_ECGPOvrd"];
        HCU_6_ECGPOvrdInvalidData = CanConfiguration::Instance().SignalParsers()["HCU_6_ECGPOvrdInvalidData"];
        APA_HCU_available = CanConfiguration::Instance().SignalParsers()["APA_HCU_available"];
        APA_HCU_DriverIntervention = CanConfiguration::Instance().SignalParsers()["APA_HCU_DriverIntervention"];
        HCU_6_MessageCounter = CanConfiguration::Instance().SignalParsers()["HCU_6_MessageCounter"];
        HCU_6_CRC = CanConfiguration::Instance().SignalParsers()["HCU_6_CRC"];
    }

    void Parser(uint8_t* payload){
        HCU_6_MaxTorqueWheel.Parser(payload);
        HCU_6_MinTorqueWheel.Parser(payload);
        HCU_6_ECGPOvrd.Parser(payload);
        HCU_6_ECGPOvrdInvalidData.Parser(payload);
        APA_HCU_available.Parser(payload);
        APA_HCU_DriverIntervention.Parser(payload);
        HCU_6_MessageCounter.Parser(payload);
        HCU_6_CRC.Parser(payload);
    }

    void CanParser2CanStruct_HCU_6_MSG(HCU_6_MSG& msg) {
        double factor;
        double offset;
        factor = HCU_6_MaxTorqueWheel.factor;
        offset = HCU_6_MaxTorqueWheel.offset;
        msg.HCU_6_MaxTorqueWheel = *reinterpret_cast<std::decay<decltype(msg.HCU_6_MaxTorqueWheel)>::type*>(&HCU_6_MaxTorqueWheel.signal);
        msg.HCU_6_MaxTorqueWheel = msg.HCU_6_MaxTorqueWheel * factor + offset;
        factor = HCU_6_MinTorqueWheel.factor;
        offset = HCU_6_MinTorqueWheel.offset;
        msg.HCU_6_MinTorqueWheel = *reinterpret_cast<std::decay<decltype(msg.HCU_6_MinTorqueWheel)>::type*>(&HCU_6_MinTorqueWheel.signal);
        msg.HCU_6_MinTorqueWheel = msg.HCU_6_MinTorqueWheel * factor + offset;
        factor = HCU_6_ECGPOvrd.factor;
        offset = HCU_6_ECGPOvrd.offset;
        msg.HCU_6_ECGPOvrd = *reinterpret_cast<std::decay<decltype(msg.HCU_6_ECGPOvrd)>::type*>(&HCU_6_ECGPOvrd.signal);
        msg.HCU_6_ECGPOvrd = msg.HCU_6_ECGPOvrd * factor + offset;
        factor = HCU_6_ECGPOvrdInvalidData.factor;
        offset = HCU_6_ECGPOvrdInvalidData.offset;
        msg.HCU_6_ECGPOvrdInvalidData = *reinterpret_cast<std::decay<decltype(msg.HCU_6_ECGPOvrdInvalidData)>::type*>(&HCU_6_ECGPOvrdInvalidData.signal);
        msg.HCU_6_ECGPOvrdInvalidData = msg.HCU_6_ECGPOvrdInvalidData * factor + offset;
        factor = APA_HCU_available.factor;
        offset = APA_HCU_available.offset;
        msg.APA_HCU_available = *reinterpret_cast<std::decay<decltype(msg.APA_HCU_available)>::type*>(&APA_HCU_available.signal);
        msg.APA_HCU_available = msg.APA_HCU_available * factor + offset;
        factor = APA_HCU_DriverIntervention.factor;
        offset = APA_HCU_DriverIntervention.offset;
        msg.APA_HCU_DriverIntervention = *reinterpret_cast<std::decay<decltype(msg.APA_HCU_DriverIntervention)>::type*>(&APA_HCU_DriverIntervention.signal);
        msg.APA_HCU_DriverIntervention = msg.APA_HCU_DriverIntervention * factor + offset;
        factor = HCU_6_MessageCounter.factor;
        offset = HCU_6_MessageCounter.offset;
        msg.HCU_6_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.HCU_6_MessageCounter)>::type*>(&HCU_6_MessageCounter.signal);
        msg.HCU_6_MessageCounter = msg.HCU_6_MessageCounter * factor + offset;
        factor = HCU_6_CRC.factor;
        offset = HCU_6_CRC.offset;
        msg.HCU_6_CRC = *reinterpret_cast<std::decay<decltype(msg.HCU_6_CRC)>::type*>(&HCU_6_CRC.signal);
        msg.HCU_6_CRC = msg.HCU_6_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_6_MSG can_struct;
        CanParser2CanStruct_HCU_6_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_6_MSGMsg>();
        Struct2Proto_HCU_6_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_6") != nullptr) {
            DFHLOG_I("hcu_6");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_6")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_6");
            return false;
         }
    }
};

struct HCU_17_Parser {
    SignalParser PRNDGearAct;

    SignalParser PRNDGearActValidData;

    SignalParser PRNDGearTarget;

    SignalParser HCU_17_MessageCounter;

    SignalParser HCU_17_CRC;

    HCU_17_Parser() {
        PRNDGearAct = CanConfiguration::Instance().SignalParsers()["PRNDGearAct"];
        PRNDGearActValidData = CanConfiguration::Instance().SignalParsers()["PRNDGearActValidData"];
        PRNDGearTarget = CanConfiguration::Instance().SignalParsers()["PRNDGearTarget"];
        HCU_17_MessageCounter = CanConfiguration::Instance().SignalParsers()["HCU_17_MessageCounter"];
        HCU_17_CRC = CanConfiguration::Instance().SignalParsers()["HCU_17_CRC"];
    }

    void Parser(uint8_t* payload){
        PRNDGearAct.Parser(payload);
        PRNDGearActValidData.Parser(payload);
        PRNDGearTarget.Parser(payload);
        HCU_17_MessageCounter.Parser(payload);
        HCU_17_CRC.Parser(payload);
    }

    void CanParser2CanStruct_HCU_17_MSG(HCU_17_MSG& msg) {
        double factor;
        double offset;
        factor = PRNDGearAct.factor;
        offset = PRNDGearAct.offset;
        msg.PRNDGearAct = *reinterpret_cast<std::decay<decltype(msg.PRNDGearAct)>::type*>(&PRNDGearAct.signal);
        msg.PRNDGearAct = msg.PRNDGearAct * factor + offset;
        factor = PRNDGearActValidData.factor;
        offset = PRNDGearActValidData.offset;
        msg.PRNDGearActValidData = *reinterpret_cast<std::decay<decltype(msg.PRNDGearActValidData)>::type*>(&PRNDGearActValidData.signal);
        msg.PRNDGearActValidData = msg.PRNDGearActValidData * factor + offset;
        factor = PRNDGearTarget.factor;
        offset = PRNDGearTarget.offset;
        msg.PRNDGearTarget = *reinterpret_cast<std::decay<decltype(msg.PRNDGearTarget)>::type*>(&PRNDGearTarget.signal);
        msg.PRNDGearTarget = msg.PRNDGearTarget * factor + offset;
        factor = HCU_17_MessageCounter.factor;
        offset = HCU_17_MessageCounter.offset;
        msg.HCU_17_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.HCU_17_MessageCounter)>::type*>(&HCU_17_MessageCounter.signal);
        msg.HCU_17_MessageCounter = msg.HCU_17_MessageCounter * factor + offset;
        factor = HCU_17_CRC.factor;
        offset = HCU_17_CRC.offset;
        msg.HCU_17_CRC = *reinterpret_cast<std::decay<decltype(msg.HCU_17_CRC)>::type*>(&HCU_17_CRC.signal);
        msg.HCU_17_CRC = msg.HCU_17_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_17_MSG can_struct;
        CanParser2CanStruct_HCU_17_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_17_MSGMsg>();
        Struct2Proto_HCU_17_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_17") != nullptr) {
            DFHLOG_I("hcu_17");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_17")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_17");
            return false;
         }
    }
};

struct HCU_1_G_Parser {
    SignalParser HCU_PTReady;

    SignalParser HCU_PowertrainFault;

    HCU_1_G_Parser() {
        HCU_PTReady = CanConfiguration::Instance().SignalParsers()["HCU_PTReady"];
        HCU_PowertrainFault = CanConfiguration::Instance().SignalParsers()["HCU_PowertrainFault"];
    }

    void Parser(uint8_t* payload){
        HCU_PTReady.Parser(payload);
        HCU_PowertrainFault.Parser(payload);
    }

    void CanParser2CanStruct_HCU_1_G_MSG(HCU_1_G_MSG& msg) {
        double factor;
        double offset;
        factor = HCU_PTReady.factor;
        offset = HCU_PTReady.offset;
        msg.HCU_PTReady = *reinterpret_cast<std::decay<decltype(msg.HCU_PTReady)>::type*>(&HCU_PTReady.signal);
        msg.HCU_PTReady = msg.HCU_PTReady * factor + offset;
        factor = HCU_PowertrainFault.factor;
        offset = HCU_PowertrainFault.offset;
        msg.HCU_PowertrainFault = *reinterpret_cast<std::decay<decltype(msg.HCU_PowertrainFault)>::type*>(&HCU_PowertrainFault.signal);
        msg.HCU_PowertrainFault = msg.HCU_PowertrainFault * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_1_G_MSG can_struct;
        CanParser2CanStruct_HCU_1_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_1_G_MSGMsg>();
        Struct2Proto_HCU_1_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_1_g") != nullptr) {
            DFHLOG_I("hcu_1_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_1_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_1_g");
            return false;
         }
    }
};

struct HCU_3_G_Parser {
    SignalParser HCU_PowerLimit;

    SignalParser HCU_GasPedalPosition;

    SignalParser HCU_GasPedalPositionInvalidData;

    SignalParser HCU_BrakePedalStsValidData;

    SignalParser HCU_BrakePedalSts;

    HCU_3_G_Parser() {
        HCU_PowerLimit = CanConfiguration::Instance().SignalParsers()["HCU_PowerLimit"];
        HCU_GasPedalPosition = CanConfiguration::Instance().SignalParsers()["HCU_GasPedalPosition"];
        HCU_GasPedalPositionInvalidData = CanConfiguration::Instance().SignalParsers()["HCU_GasPedalPositionInvalidData"];
        HCU_BrakePedalStsValidData = CanConfiguration::Instance().SignalParsers()["HCU_BrakePedalStsValidData"];
        HCU_BrakePedalSts = CanConfiguration::Instance().SignalParsers()["HCU_BrakePedalSts"];
    }

    void Parser(uint8_t* payload){
        HCU_PowerLimit.Parser(payload);
        HCU_GasPedalPosition.Parser(payload);
        HCU_GasPedalPositionInvalidData.Parser(payload);
        HCU_BrakePedalStsValidData.Parser(payload);
        HCU_BrakePedalSts.Parser(payload);
    }

    void CanParser2CanStruct_HCU_3_G_MSG(HCU_3_G_MSG& msg) {
        double factor;
        double offset;
        factor = HCU_PowerLimit.factor;
        offset = HCU_PowerLimit.offset;
        msg.HCU_PowerLimit = *reinterpret_cast<std::decay<decltype(msg.HCU_PowerLimit)>::type*>(&HCU_PowerLimit.signal);
        msg.HCU_PowerLimit = msg.HCU_PowerLimit * factor + offset;
        factor = HCU_GasPedalPosition.factor;
        offset = HCU_GasPedalPosition.offset;
        msg.HCU_GasPedalPosition = *reinterpret_cast<std::decay<decltype(msg.HCU_GasPedalPosition)>::type*>(&HCU_GasPedalPosition.signal);
        msg.HCU_GasPedalPosition = msg.HCU_GasPedalPosition * factor + offset;
        factor = HCU_GasPedalPositionInvalidData.factor;
        offset = HCU_GasPedalPositionInvalidData.offset;
        msg.HCU_GasPedalPositionInvalidData = *reinterpret_cast<std::decay<decltype(msg.HCU_GasPedalPositionInvalidData)>::type*>(&HCU_GasPedalPositionInvalidData.signal);
        msg.HCU_GasPedalPositionInvalidData = msg.HCU_GasPedalPositionInvalidData * factor + offset;
        factor = HCU_BrakePedalStsValidData.factor;
        offset = HCU_BrakePedalStsValidData.offset;
        msg.HCU_BrakePedalStsValidData = *reinterpret_cast<std::decay<decltype(msg.HCU_BrakePedalStsValidData)>::type*>(&HCU_BrakePedalStsValidData.signal);
        msg.HCU_BrakePedalStsValidData = msg.HCU_BrakePedalStsValidData * factor + offset;
        factor = HCU_BrakePedalSts.factor;
        offset = HCU_BrakePedalSts.offset;
        msg.HCU_BrakePedalSts = *reinterpret_cast<std::decay<decltype(msg.HCU_BrakePedalSts)>::type*>(&HCU_BrakePedalSts.signal);
        msg.HCU_BrakePedalSts = msg.HCU_BrakePedalSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        HCU_3_G_MSG can_struct;
        CanParser2CanStruct_HCU_3_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::HCU_3_G_MSGMsg>();
        Struct2Proto_HCU_3_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("hcu_3_g") != nullptr) {
            DFHLOG_I("hcu_3_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("hcu_3_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port hcu_3_g");
            return false;
         }
    }
};

struct ICM_1_Parser {
    SignalParser DisplayVehicleSpeed;

    SignalParser ECOModeSWSts;

    SignalParser TotalOdometer_km;

    ICM_1_Parser() {
        DisplayVehicleSpeed = CanConfiguration::Instance().SignalParsers()["DisplayVehicleSpeed"];
        ECOModeSWSts = CanConfiguration::Instance().SignalParsers()["ECOModeSWSts"];
        TotalOdometer_km = CanConfiguration::Instance().SignalParsers()["TotalOdometer_km"];
    }

    void Parser(uint8_t* payload){
        DisplayVehicleSpeed.Parser(payload);
        ECOModeSWSts.Parser(payload);
        TotalOdometer_km.Parser(payload);
    }

    void CanParser2CanStruct_ICM_1_MSG(ICM_1_MSG& msg) {
        double factor;
        double offset;
        factor = DisplayVehicleSpeed.factor;
        offset = DisplayVehicleSpeed.offset;
        msg.DisplayVehicleSpeed = *reinterpret_cast<std::decay<decltype(msg.DisplayVehicleSpeed)>::type*>(&DisplayVehicleSpeed.signal);
        msg.DisplayVehicleSpeed = msg.DisplayVehicleSpeed * factor + offset;
        factor = ECOModeSWSts.factor;
        offset = ECOModeSWSts.offset;
        msg.ECOModeSWSts = *reinterpret_cast<std::decay<decltype(msg.ECOModeSWSts)>::type*>(&ECOModeSWSts.signal);
        msg.ECOModeSWSts = msg.ECOModeSWSts * factor + offset;
        factor = TotalOdometer_km.factor;
        offset = TotalOdometer_km.offset;
        msg.TotalOdometer_km = *reinterpret_cast<std::decay<decltype(msg.TotalOdometer_km)>::type*>(&TotalOdometer_km.signal);
        msg.TotalOdometer_km = msg.TotalOdometer_km * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ICM_1_MSG can_struct;
        CanParser2CanStruct_ICM_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ICM_1_MSGMsg>();
        Struct2Proto_ICM_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("icm_1") != nullptr) {
            DFHLOG_I("icm_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("icm_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port icm_1");
            return false;
         }
    }
};

struct ICM_2_Parser {
    SignalParser DISFail;

    SignalParser QDashACCFail;

    ICM_2_Parser() {
        DISFail = CanConfiguration::Instance().SignalParsers()["DISFail"];
        QDashACCFail = CanConfiguration::Instance().SignalParsers()["QDashACCFail"];
    }

    void Parser(uint8_t* payload){
        DISFail.Parser(payload);
        QDashACCFail.Parser(payload);
    }

    void CanParser2CanStruct_ICM_2_MSG(ICM_2_MSG& msg) {
        double factor;
        double offset;
        factor = DISFail.factor;
        offset = DISFail.offset;
        msg.DISFail = *reinterpret_cast<std::decay<decltype(msg.DISFail)>::type*>(&DISFail.signal);
        msg.DISFail = msg.DISFail * factor + offset;
        factor = QDashACCFail.factor;
        offset = QDashACCFail.offset;
        msg.QDashACCFail = *reinterpret_cast<std::decay<decltype(msg.QDashACCFail)>::type*>(&QDashACCFail.signal);
        msg.QDashACCFail = msg.QDashACCFail * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ICM_2_MSG can_struct;
        CanParser2CanStruct_ICM_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ICM_2_MSGMsg>();
        Struct2Proto_ICM_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("icm_2") != nullptr) {
            DFHLOG_I("icm_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("icm_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port icm_2");
            return false;
         }
    }
};

struct ICM_3_Parser {
    SignalParser CurrentTimeHour;

    SignalParser CurrentTimeMinute;

    SignalParser CurrentTimeSecond;

    SignalParser CurrentTimeDay;

    SignalParser CurrentTimeMonth;

    SignalParser CurrentTimeYear;

    ICM_3_Parser() {
        CurrentTimeHour = CanConfiguration::Instance().SignalParsers()["CurrentTimeHour"];
        CurrentTimeMinute = CanConfiguration::Instance().SignalParsers()["CurrentTimeMinute"];
        CurrentTimeSecond = CanConfiguration::Instance().SignalParsers()["CurrentTimeSecond"];
        CurrentTimeDay = CanConfiguration::Instance().SignalParsers()["CurrentTimeDay"];
        CurrentTimeMonth = CanConfiguration::Instance().SignalParsers()["CurrentTimeMonth"];
        CurrentTimeYear = CanConfiguration::Instance().SignalParsers()["CurrentTimeYear"];
    }

    void Parser(uint8_t* payload){
        CurrentTimeHour.Parser(payload);
        CurrentTimeMinute.Parser(payload);
        CurrentTimeSecond.Parser(payload);
        CurrentTimeDay.Parser(payload);
        CurrentTimeMonth.Parser(payload);
        CurrentTimeYear.Parser(payload);
    }

    void CanParser2CanStruct_ICM_3_MSG(ICM_3_MSG& msg) {
        double factor;
        double offset;
        factor = CurrentTimeHour.factor;
        offset = CurrentTimeHour.offset;
        msg.CurrentTimeHour = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeHour)>::type*>(&CurrentTimeHour.signal);
        msg.CurrentTimeHour = msg.CurrentTimeHour * factor + offset;
        factor = CurrentTimeMinute.factor;
        offset = CurrentTimeMinute.offset;
        msg.CurrentTimeMinute = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeMinute)>::type*>(&CurrentTimeMinute.signal);
        msg.CurrentTimeMinute = msg.CurrentTimeMinute * factor + offset;
        factor = CurrentTimeSecond.factor;
        offset = CurrentTimeSecond.offset;
        msg.CurrentTimeSecond = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeSecond)>::type*>(&CurrentTimeSecond.signal);
        msg.CurrentTimeSecond = msg.CurrentTimeSecond * factor + offset;
        factor = CurrentTimeDay.factor;
        offset = CurrentTimeDay.offset;
        msg.CurrentTimeDay = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeDay)>::type*>(&CurrentTimeDay.signal);
        msg.CurrentTimeDay = msg.CurrentTimeDay * factor + offset;
        factor = CurrentTimeMonth.factor;
        offset = CurrentTimeMonth.offset;
        msg.CurrentTimeMonth = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeMonth)>::type*>(&CurrentTimeMonth.signal);
        msg.CurrentTimeMonth = msg.CurrentTimeMonth * factor + offset;
        factor = CurrentTimeYear.factor;
        offset = CurrentTimeYear.offset;
        msg.CurrentTimeYear = *reinterpret_cast<std::decay<decltype(msg.CurrentTimeYear)>::type*>(&CurrentTimeYear.signal);
        msg.CurrentTimeYear = msg.CurrentTimeYear * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ICM_3_MSG can_struct;
        CanParser2CanStruct_ICM_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ICM_3_MSGMsg>();
        Struct2Proto_ICM_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("icm_3") != nullptr) {
            DFHLOG_I("icm_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("icm_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port icm_3");
            return false;
         }
    }
};

struct ICM_5_Parser {
    SignalParser ICM_5_DriverSeatBeltSwitch;

    SignalParser DriverSeatBeltSwitchQbit;

    SignalParser ACC_Kilometre_Mile;

    SignalParser ICM_5_MessageCounter;

    SignalParser ICM_5_Checksum;

    ICM_5_Parser() {
        ICM_5_DriverSeatBeltSwitch = CanConfiguration::Instance().SignalParsers()["ICM_5_DriverSeatBeltSwitch"];
        DriverSeatBeltSwitchQbit = CanConfiguration::Instance().SignalParsers()["DriverSeatBeltSwitchQbit"];
        ACC_Kilometre_Mile = CanConfiguration::Instance().SignalParsers()["ACC_Kilometre_Mile"];
        ICM_5_MessageCounter = CanConfiguration::Instance().SignalParsers()["ICM_5_MessageCounter"];
        ICM_5_Checksum = CanConfiguration::Instance().SignalParsers()["ICM_5_Checksum"];
    }

    void Parser(uint8_t* payload){
        ICM_5_DriverSeatBeltSwitch.Parser(payload);
        DriverSeatBeltSwitchQbit.Parser(payload);
        ACC_Kilometre_Mile.Parser(payload);
        ICM_5_MessageCounter.Parser(payload);
        ICM_5_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_ICM_5_MSG(ICM_5_MSG& msg) {
        double factor;
        double offset;
        factor = ICM_5_DriverSeatBeltSwitch.factor;
        offset = ICM_5_DriverSeatBeltSwitch.offset;
        msg.ICM_5_DriverSeatBeltSwitch = *reinterpret_cast<std::decay<decltype(msg.ICM_5_DriverSeatBeltSwitch)>::type*>(&ICM_5_DriverSeatBeltSwitch.signal);
        msg.ICM_5_DriverSeatBeltSwitch = msg.ICM_5_DriverSeatBeltSwitch * factor + offset;
        factor = DriverSeatBeltSwitchQbit.factor;
        offset = DriverSeatBeltSwitchQbit.offset;
        msg.DriverSeatBeltSwitchQbit = *reinterpret_cast<std::decay<decltype(msg.DriverSeatBeltSwitchQbit)>::type*>(&DriverSeatBeltSwitchQbit.signal);
        msg.DriverSeatBeltSwitchQbit = msg.DriverSeatBeltSwitchQbit * factor + offset;
        factor = ACC_Kilometre_Mile.factor;
        offset = ACC_Kilometre_Mile.offset;
        msg.ACC_Kilometre_Mile = *reinterpret_cast<std::decay<decltype(msg.ACC_Kilometre_Mile)>::type*>(&ACC_Kilometre_Mile.signal);
        msg.ACC_Kilometre_Mile = msg.ACC_Kilometre_Mile * factor + offset;
        factor = ICM_5_MessageCounter.factor;
        offset = ICM_5_MessageCounter.offset;
        msg.ICM_5_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.ICM_5_MessageCounter)>::type*>(&ICM_5_MessageCounter.signal);
        msg.ICM_5_MessageCounter = msg.ICM_5_MessageCounter * factor + offset;
        factor = ICM_5_Checksum.factor;
        offset = ICM_5_Checksum.offset;
        msg.ICM_5_Checksum = *reinterpret_cast<std::decay<decltype(msg.ICM_5_Checksum)>::type*>(&ICM_5_Checksum.signal);
        msg.ICM_5_Checksum = msg.ICM_5_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        ICM_5_MSG can_struct;
        CanParser2CanStruct_ICM_5_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::ICM_5_MSGMsg>();
        Struct2Proto_ICM_5_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("icm_5") != nullptr) {
            DFHLOG_I("icm_5");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("icm_5")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port icm_5");
            return false;
         }
    }
};

struct IPB_11_Parser {
    SignalParser IPB_InputRodStroke;

    SignalParser IPB_InputRodStrokeStatus;

    SignalParser IPB_PlungerPressure;

    SignalParser IPB_PlungerPressureValidData;

    SignalParser IPB_ESP_11_MessageCounter;

    SignalParser IPB_ESP_11_CRC;

    IPB_11_Parser() {
        IPB_InputRodStroke = CanConfiguration::Instance().SignalParsers()["IPB_InputRodStroke"];
        IPB_InputRodStrokeStatus = CanConfiguration::Instance().SignalParsers()["IPB_InputRodStrokeStatus"];
        IPB_PlungerPressure = CanConfiguration::Instance().SignalParsers()["IPB_PlungerPressure"];
        IPB_PlungerPressureValidData = CanConfiguration::Instance().SignalParsers()["IPB_PlungerPressureValidData"];
        IPB_ESP_11_MessageCounter = CanConfiguration::Instance().SignalParsers()["IPB_ESP_11_MessageCounter"];
        IPB_ESP_11_CRC = CanConfiguration::Instance().SignalParsers()["IPB_ESP_11_CRC"];
    }

    void Parser(uint8_t* payload){
        IPB_InputRodStroke.Parser(payload);
        IPB_InputRodStrokeStatus.Parser(payload);
        IPB_PlungerPressure.Parser(payload);
        IPB_PlungerPressureValidData.Parser(payload);
        IPB_ESP_11_MessageCounter.Parser(payload);
        IPB_ESP_11_CRC.Parser(payload);
    }

    void CanParser2CanStruct_IPB_11_MSG(IPB_11_MSG& msg) {
        double factor;
        double offset;
        factor = IPB_InputRodStroke.factor;
        offset = IPB_InputRodStroke.offset;
        msg.IPB_InputRodStroke = *reinterpret_cast<std::decay<decltype(msg.IPB_InputRodStroke)>::type*>(&IPB_InputRodStroke.signal);
        msg.IPB_InputRodStroke = msg.IPB_InputRodStroke * factor + offset;
        factor = IPB_InputRodStrokeStatus.factor;
        offset = IPB_InputRodStrokeStatus.offset;
        msg.IPB_InputRodStrokeStatus = *reinterpret_cast<std::decay<decltype(msg.IPB_InputRodStrokeStatus)>::type*>(&IPB_InputRodStrokeStatus.signal);
        msg.IPB_InputRodStrokeStatus = msg.IPB_InputRodStrokeStatus * factor + offset;
        factor = IPB_PlungerPressure.factor;
        offset = IPB_PlungerPressure.offset;
        msg.IPB_PlungerPressure = *reinterpret_cast<std::decay<decltype(msg.IPB_PlungerPressure)>::type*>(&IPB_PlungerPressure.signal);
        msg.IPB_PlungerPressure = msg.IPB_PlungerPressure * factor + offset;
        factor = IPB_PlungerPressureValidData.factor;
        offset = IPB_PlungerPressureValidData.offset;
        msg.IPB_PlungerPressureValidData = *reinterpret_cast<std::decay<decltype(msg.IPB_PlungerPressureValidData)>::type*>(&IPB_PlungerPressureValidData.signal);
        msg.IPB_PlungerPressureValidData = msg.IPB_PlungerPressureValidData * factor + offset;
        factor = IPB_ESP_11_MessageCounter.factor;
        offset = IPB_ESP_11_MessageCounter.offset;
        msg.IPB_ESP_11_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.IPB_ESP_11_MessageCounter)>::type*>(&IPB_ESP_11_MessageCounter.signal);
        msg.IPB_ESP_11_MessageCounter = msg.IPB_ESP_11_MessageCounter * factor + offset;
        factor = IPB_ESP_11_CRC.factor;
        offset = IPB_ESP_11_CRC.offset;
        msg.IPB_ESP_11_CRC = *reinterpret_cast<std::decay<decltype(msg.IPB_ESP_11_CRC)>::type*>(&IPB_ESP_11_CRC.signal);
        msg.IPB_ESP_11_CRC = msg.IPB_ESP_11_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IPB_11_MSG can_struct;
        CanParser2CanStruct_IPB_11_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IPB_11_MSGMsg>();
        Struct2Proto_IPB_11_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ipb_11") != nullptr) {
            DFHLOG_I("ipb_11");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ipb_11")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ipb_11");
            return false;
         }
    }
};

struct MFS_2_Parser {
    SignalParser CHKSM_MFS_2;

    SignalParser ALIVE_MFS_2;

    SignalParser MFS_2_LeftRoller;

    SignalParser MFS_Cruise_Control;

    SignalParser MFS_RESPlus;

    SignalParser MFS_SETMinus;

    SignalParser MFS_2_LeRollrUpDwnAdjSteps;

    SignalParser MFS_Time_Gap_Add;

    SignalParser MFS_Time_Gap_Reduce;

    MFS_2_Parser() {
        CHKSM_MFS_2 = CanConfiguration::Instance().SignalParsers()["CHKSM_MFS_2"];
        ALIVE_MFS_2 = CanConfiguration::Instance().SignalParsers()["ALIVE_MFS_2"];
        MFS_2_LeftRoller = CanConfiguration::Instance().SignalParsers()["MFS_2_LeftRoller"];
        MFS_Cruise_Control = CanConfiguration::Instance().SignalParsers()["MFS_Cruise_Control"];
        MFS_RESPlus = CanConfiguration::Instance().SignalParsers()["MFS_RESPlus"];
        MFS_SETMinus = CanConfiguration::Instance().SignalParsers()["MFS_SETMinus"];
        MFS_2_LeRollrUpDwnAdjSteps = CanConfiguration::Instance().SignalParsers()["MFS_2_LeRollrUpDwnAdjSteps"];
        MFS_Time_Gap_Add = CanConfiguration::Instance().SignalParsers()["MFS_Time_Gap_Add"];
        MFS_Time_Gap_Reduce = CanConfiguration::Instance().SignalParsers()["MFS_Time_Gap_Reduce"];
    }

    void Parser(uint8_t* payload){
        CHKSM_MFS_2.Parser(payload);
        ALIVE_MFS_2.Parser(payload);
        MFS_2_LeftRoller.Parser(payload);
        MFS_Cruise_Control.Parser(payload);
        MFS_RESPlus.Parser(payload);
        MFS_SETMinus.Parser(payload);
        MFS_2_LeRollrUpDwnAdjSteps.Parser(payload);
        MFS_Time_Gap_Add.Parser(payload);
        MFS_Time_Gap_Reduce.Parser(payload);
    }

    void CanParser2CanStruct_MFS_2_MSG(MFS_2_MSG& msg) {
        double factor;
        double offset;
        factor = CHKSM_MFS_2.factor;
        offset = CHKSM_MFS_2.offset;
        msg.CHKSM_MFS_2 = *reinterpret_cast<std::decay<decltype(msg.CHKSM_MFS_2)>::type*>(&CHKSM_MFS_2.signal);
        msg.CHKSM_MFS_2 = msg.CHKSM_MFS_2 * factor + offset;
        factor = ALIVE_MFS_2.factor;
        offset = ALIVE_MFS_2.offset;
        msg.ALIVE_MFS_2 = *reinterpret_cast<std::decay<decltype(msg.ALIVE_MFS_2)>::type*>(&ALIVE_MFS_2.signal);
        msg.ALIVE_MFS_2 = msg.ALIVE_MFS_2 * factor + offset;
        factor = MFS_2_LeftRoller.factor;
        offset = MFS_2_LeftRoller.offset;
        msg.MFS_2_LeftRoller = *reinterpret_cast<std::decay<decltype(msg.MFS_2_LeftRoller)>::type*>(&MFS_2_LeftRoller.signal);
        msg.MFS_2_LeftRoller = msg.MFS_2_LeftRoller * factor + offset;
        factor = MFS_Cruise_Control.factor;
        offset = MFS_Cruise_Control.offset;
        msg.MFS_Cruise_Control = *reinterpret_cast<std::decay<decltype(msg.MFS_Cruise_Control)>::type*>(&MFS_Cruise_Control.signal);
        msg.MFS_Cruise_Control = msg.MFS_Cruise_Control * factor + offset;
        factor = MFS_RESPlus.factor;
        offset = MFS_RESPlus.offset;
        msg.MFS_RESPlus = *reinterpret_cast<std::decay<decltype(msg.MFS_RESPlus)>::type*>(&MFS_RESPlus.signal);
        msg.MFS_RESPlus = msg.MFS_RESPlus * factor + offset;
        factor = MFS_SETMinus.factor;
        offset = MFS_SETMinus.offset;
        msg.MFS_SETMinus = *reinterpret_cast<std::decay<decltype(msg.MFS_SETMinus)>::type*>(&MFS_SETMinus.signal);
        msg.MFS_SETMinus = msg.MFS_SETMinus * factor + offset;
        factor = MFS_2_LeRollrUpDwnAdjSteps.factor;
        offset = MFS_2_LeRollrUpDwnAdjSteps.offset;
        msg.MFS_2_LeRollrUpDwnAdjSteps = *reinterpret_cast<std::decay<decltype(msg.MFS_2_LeRollrUpDwnAdjSteps)>::type*>(&MFS_2_LeRollrUpDwnAdjSteps.signal);
        msg.MFS_2_LeRollrUpDwnAdjSteps = msg.MFS_2_LeRollrUpDwnAdjSteps * factor + offset;
        factor = MFS_Time_Gap_Add.factor;
        offset = MFS_Time_Gap_Add.offset;
        msg.MFS_Time_Gap_Add = *reinterpret_cast<std::decay<decltype(msg.MFS_Time_Gap_Add)>::type*>(&MFS_Time_Gap_Add.signal);
        msg.MFS_Time_Gap_Add = msg.MFS_Time_Gap_Add * factor + offset;
        factor = MFS_Time_Gap_Reduce.factor;
        offset = MFS_Time_Gap_Reduce.offset;
        msg.MFS_Time_Gap_Reduce = *reinterpret_cast<std::decay<decltype(msg.MFS_Time_Gap_Reduce)>::type*>(&MFS_Time_Gap_Reduce.signal);
        msg.MFS_Time_Gap_Reduce = msg.MFS_Time_Gap_Reduce * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        MFS_2_MSG can_struct;
        CanParser2CanStruct_MFS_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::MFS_2_MSGMsg>();
        Struct2Proto_MFS_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("mfs_2") != nullptr) {
            DFHLOG_I("mfs_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("mfs_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port mfs_2");
            return false;
         }
    }
};

struct PEPS_1_Parser {
    SignalParser RemoteStartSts;

    SignalParser RemoteStartFailCode_1;

    SignalParser PEPS_1_MessageCounter;

    SignalParser PEPS_1_Checksum;

    PEPS_1_Parser() {
        RemoteStartSts = CanConfiguration::Instance().SignalParsers()["RemoteStartSts"];
        RemoteStartFailCode_1 = CanConfiguration::Instance().SignalParsers()["RemoteStartFailCode_1"];
        PEPS_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["PEPS_1_MessageCounter"];
        PEPS_1_Checksum = CanConfiguration::Instance().SignalParsers()["PEPS_1_Checksum"];
    }

    void Parser(uint8_t* payload){
        RemoteStartSts.Parser(payload);
        RemoteStartFailCode_1.Parser(payload);
        PEPS_1_MessageCounter.Parser(payload);
        PEPS_1_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_PEPS_1_MSG(PEPS_1_MSG& msg) {
        double factor;
        double offset;
        factor = RemoteStartSts.factor;
        offset = RemoteStartSts.offset;
        msg.RemoteStartSts = *reinterpret_cast<std::decay<decltype(msg.RemoteStartSts)>::type*>(&RemoteStartSts.signal);
        msg.RemoteStartSts = msg.RemoteStartSts * factor + offset;
        factor = RemoteStartFailCode_1.factor;
        offset = RemoteStartFailCode_1.offset;
        msg.RemoteStartFailCode_1 = *reinterpret_cast<std::decay<decltype(msg.RemoteStartFailCode_1)>::type*>(&RemoteStartFailCode_1.signal);
        msg.RemoteStartFailCode_1 = msg.RemoteStartFailCode_1 * factor + offset;
        factor = PEPS_1_MessageCounter.factor;
        offset = PEPS_1_MessageCounter.offset;
        msg.PEPS_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.PEPS_1_MessageCounter)>::type*>(&PEPS_1_MessageCounter.signal);
        msg.PEPS_1_MessageCounter = msg.PEPS_1_MessageCounter * factor + offset;
        factor = PEPS_1_Checksum.factor;
        offset = PEPS_1_Checksum.offset;
        msg.PEPS_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.PEPS_1_Checksum)>::type*>(&PEPS_1_Checksum.signal);
        msg.PEPS_1_Checksum = msg.PEPS_1_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        PEPS_1_MSG can_struct;
        CanParser2CanStruct_PEPS_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::PEPS_1_MSGMsg>();
        Struct2Proto_PEPS_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("peps_1") != nullptr) {
            DFHLOG_I("peps_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("peps_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port peps_1");
            return false;
         }
    }
};

struct PEPS_2_Parser {
    SignalParser PEPS_PowerMode;

    SignalParser PEPS_2_MessageCounter;

    SignalParser PEPS_2_CRC;

    PEPS_2_Parser() {
        PEPS_PowerMode = CanConfiguration::Instance().SignalParsers()["PEPS_PowerMode"];
        PEPS_2_MessageCounter = CanConfiguration::Instance().SignalParsers()["PEPS_2_MessageCounter"];
        PEPS_2_CRC = CanConfiguration::Instance().SignalParsers()["PEPS_2_CRC"];
    }

    void Parser(uint8_t* payload){
        PEPS_PowerMode.Parser(payload);
        PEPS_2_MessageCounter.Parser(payload);
        PEPS_2_CRC.Parser(payload);
    }

    void CanParser2CanStruct_PEPS_2_MSG(PEPS_2_MSG& msg) {
        double factor;
        double offset;
        factor = PEPS_PowerMode.factor;
        offset = PEPS_PowerMode.offset;
        msg.PEPS_PowerMode = *reinterpret_cast<std::decay<decltype(msg.PEPS_PowerMode)>::type*>(&PEPS_PowerMode.signal);
        msg.PEPS_PowerMode = msg.PEPS_PowerMode * factor + offset;
        factor = PEPS_2_MessageCounter.factor;
        offset = PEPS_2_MessageCounter.offset;
        msg.PEPS_2_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.PEPS_2_MessageCounter)>::type*>(&PEPS_2_MessageCounter.signal);
        msg.PEPS_2_MessageCounter = msg.PEPS_2_MessageCounter * factor + offset;
        factor = PEPS_2_CRC.factor;
        offset = PEPS_2_CRC.offset;
        msg.PEPS_2_CRC = *reinterpret_cast<std::decay<decltype(msg.PEPS_2_CRC)>::type*>(&PEPS_2_CRC.signal);
        msg.PEPS_2_CRC = msg.PEPS_2_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        PEPS_2_MSG can_struct;
        CanParser2CanStruct_PEPS_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::PEPS_2_MSGMsg>();
        Struct2Proto_PEPS_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("peps_2") != nullptr) {
            DFHLOG_I("peps_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("peps_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port peps_2");
            return false;
         }
    }
};

struct BDM_25_Parser {
    SignalParser BDM_25_FWBrightness;

    SignalParser BDM_25_ParkFrntEna;

    SignalParser BDM_25_ParkBackEna;

    SignalParser BDM_25_AVPFctReq;

    SignalParser BDM_25_AVPActv;

    SignalParser BDM_25_AmbBrightness;

    SignalParser BDM_25_IRBrightness;

    SignalParser BDM_25_MessageCounter;

    SignalParser BDM_25_CRC;

    BDM_25_Parser() {
        BDM_25_FWBrightness = CanConfiguration::Instance().SignalParsers()["BDM_25_FWBrightness"];
        BDM_25_ParkFrntEna = CanConfiguration::Instance().SignalParsers()["BDM_25_ParkFrntEna"];
        BDM_25_ParkBackEna = CanConfiguration::Instance().SignalParsers()["BDM_25_ParkBackEna"];
        BDM_25_AVPFctReq = CanConfiguration::Instance().SignalParsers()["BDM_25_AVPFctReq"];
        BDM_25_AVPActv = CanConfiguration::Instance().SignalParsers()["BDM_25_AVPActv"];
        BDM_25_AmbBrightness = CanConfiguration::Instance().SignalParsers()["BDM_25_AmbBrightness"];
        BDM_25_IRBrightness = CanConfiguration::Instance().SignalParsers()["BDM_25_IRBrightness"];
        BDM_25_MessageCounter = CanConfiguration::Instance().SignalParsers()["BDM_25_MessageCounter"];
        BDM_25_CRC = CanConfiguration::Instance().SignalParsers()["BDM_25_CRC"];
    }

    void Parser(uint8_t* payload){
        BDM_25_FWBrightness.Parser(payload);
        BDM_25_ParkFrntEna.Parser(payload);
        BDM_25_ParkBackEna.Parser(payload);
        BDM_25_AVPFctReq.Parser(payload);
        BDM_25_AVPActv.Parser(payload);
        BDM_25_AmbBrightness.Parser(payload);
        BDM_25_IRBrightness.Parser(payload);
        BDM_25_MessageCounter.Parser(payload);
        BDM_25_CRC.Parser(payload);
    }

    void CanParser2CanStruct_BDM_25_MSG(BDM_25_MSG& msg) {
        double factor;
        double offset;
        factor = BDM_25_FWBrightness.factor;
        offset = BDM_25_FWBrightness.offset;
        msg.BDM_25_FWBrightness = *reinterpret_cast<std::decay<decltype(msg.BDM_25_FWBrightness)>::type*>(&BDM_25_FWBrightness.signal);
        msg.BDM_25_FWBrightness = msg.BDM_25_FWBrightness * factor + offset;
        factor = BDM_25_ParkFrntEna.factor;
        offset = BDM_25_ParkFrntEna.offset;
        msg.BDM_25_ParkFrntEna = *reinterpret_cast<std::decay<decltype(msg.BDM_25_ParkFrntEna)>::type*>(&BDM_25_ParkFrntEna.signal);
        msg.BDM_25_ParkFrntEna = msg.BDM_25_ParkFrntEna * factor + offset;
        factor = BDM_25_ParkBackEna.factor;
        offset = BDM_25_ParkBackEna.offset;
        msg.BDM_25_ParkBackEna = *reinterpret_cast<std::decay<decltype(msg.BDM_25_ParkBackEna)>::type*>(&BDM_25_ParkBackEna.signal);
        msg.BDM_25_ParkBackEna = msg.BDM_25_ParkBackEna * factor + offset;
        factor = BDM_25_AVPFctReq.factor;
        offset = BDM_25_AVPFctReq.offset;
        msg.BDM_25_AVPFctReq = *reinterpret_cast<std::decay<decltype(msg.BDM_25_AVPFctReq)>::type*>(&BDM_25_AVPFctReq.signal);
        msg.BDM_25_AVPFctReq = msg.BDM_25_AVPFctReq * factor + offset;
        factor = BDM_25_AVPActv.factor;
        offset = BDM_25_AVPActv.offset;
        msg.BDM_25_AVPActv = *reinterpret_cast<std::decay<decltype(msg.BDM_25_AVPActv)>::type*>(&BDM_25_AVPActv.signal);
        msg.BDM_25_AVPActv = msg.BDM_25_AVPActv * factor + offset;
        factor = BDM_25_AmbBrightness.factor;
        offset = BDM_25_AmbBrightness.offset;
        msg.BDM_25_AmbBrightness = *reinterpret_cast<std::decay<decltype(msg.BDM_25_AmbBrightness)>::type*>(&BDM_25_AmbBrightness.signal);
        msg.BDM_25_AmbBrightness = msg.BDM_25_AmbBrightness * factor + offset;
        factor = BDM_25_IRBrightness.factor;
        offset = BDM_25_IRBrightness.offset;
        msg.BDM_25_IRBrightness = *reinterpret_cast<std::decay<decltype(msg.BDM_25_IRBrightness)>::type*>(&BDM_25_IRBrightness.signal);
        msg.BDM_25_IRBrightness = msg.BDM_25_IRBrightness * factor + offset;
        factor = BDM_25_MessageCounter.factor;
        offset = BDM_25_MessageCounter.offset;
        msg.BDM_25_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.BDM_25_MessageCounter)>::type*>(&BDM_25_MessageCounter.signal);
        msg.BDM_25_MessageCounter = msg.BDM_25_MessageCounter * factor + offset;
        factor = BDM_25_CRC.factor;
        offset = BDM_25_CRC.offset;
        msg.BDM_25_CRC = *reinterpret_cast<std::decay<decltype(msg.BDM_25_CRC)>::type*>(&BDM_25_CRC.signal);
        msg.BDM_25_CRC = msg.BDM_25_CRC * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        BDM_25_MSG can_struct;
        CanParser2CanStruct_BDM_25_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::BDM_25_MSGMsg>();
        Struct2Proto_BDM_25_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("bdm_25") != nullptr) {
            DFHLOG_I("bdm_25");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("bdm_25")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port bdm_25");
            return false;
         }
    }
};

struct PPMI_1_Parser {
    SignalParser PPMISt;

    SignalParser HWSt;

    PPMI_1_Parser() {
        PPMISt = CanConfiguration::Instance().SignalParsers()["PPMISt"];
        HWSt = CanConfiguration::Instance().SignalParsers()["HWSt"];
    }

    void Parser(uint8_t* payload){
        PPMISt.Parser(payload);
        HWSt.Parser(payload);
    }

    void CanParser2CanStruct_PPMI_1_MSG(PPMI_1_MSG& msg) {
        double factor;
        double offset;
        factor = PPMISt.factor;
        offset = PPMISt.offset;
        msg.PPMISt = *reinterpret_cast<std::decay<decltype(msg.PPMISt)>::type*>(&PPMISt.signal);
        msg.PPMISt = msg.PPMISt * factor + offset;
        factor = HWSt.factor;
        offset = HWSt.offset;
        msg.HWSt = *reinterpret_cast<std::decay<decltype(msg.HWSt)>::type*>(&HWSt.signal);
        msg.HWSt = msg.HWSt * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        PPMI_1_MSG can_struct;
        CanParser2CanStruct_PPMI_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::PPMI_1_MSGMsg>();
        Struct2Proto_PPMI_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ppmi_1") != nullptr) {
            DFHLOG_I("ppmi_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ppmi_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ppmi_1");
            return false;
         }
    }
};

struct SAM_1_G_Parser {
    SignalParser SteeringAngle;

    SignalParser SteeringAngleSpeed;

    SignalParser AngleFailure;

    SignalParser SteeringAngleValidData;

    SignalParser SteeringAngleSpeedValidData;

    SignalParser SAM_1_G_MessageCounter;

    SignalParser SAM_1_GCRCCheck;

    SAM_1_G_Parser() {
        SteeringAngle = CanConfiguration::Instance().SignalParsers()["SteeringAngle"];
        SteeringAngleSpeed = CanConfiguration::Instance().SignalParsers()["SteeringAngleSpeed"];
        AngleFailure = CanConfiguration::Instance().SignalParsers()["AngleFailure"];
        SteeringAngleValidData = CanConfiguration::Instance().SignalParsers()["SteeringAngleValidData"];
        SteeringAngleSpeedValidData = CanConfiguration::Instance().SignalParsers()["SteeringAngleSpeedValidData"];
        SAM_1_G_MessageCounter = CanConfiguration::Instance().SignalParsers()["SAM_1_G_MessageCounter"];
        SAM_1_GCRCCheck = CanConfiguration::Instance().SignalParsers()["SAM_1_GCRCCheck"];
    }

    void Parser(uint8_t* payload){
        SteeringAngle.Parser(payload);
        SteeringAngleSpeed.Parser(payload);
        AngleFailure.Parser(payload);
        SteeringAngleValidData.Parser(payload);
        SteeringAngleSpeedValidData.Parser(payload);
        SAM_1_G_MessageCounter.Parser(payload);
        SAM_1_GCRCCheck.Parser(payload);
    }

    void CanParser2CanStruct_SAM_1_G_MSG(SAM_1_G_MSG& msg) {
        double factor;
        double offset;
        factor = SteeringAngle.factor;
        offset = SteeringAngle.offset;
        msg.SteeringAngle = *reinterpret_cast<std::decay<decltype(msg.SteeringAngle)>::type*>(&SteeringAngle.signal);
        msg.SteeringAngle = msg.SteeringAngle * factor + offset;
        factor = SteeringAngleSpeed.factor;
        offset = SteeringAngleSpeed.offset;
        msg.SteeringAngleSpeed = *reinterpret_cast<std::decay<decltype(msg.SteeringAngleSpeed)>::type*>(&SteeringAngleSpeed.signal);
        msg.SteeringAngleSpeed = msg.SteeringAngleSpeed * factor + offset;
        factor = AngleFailure.factor;
        offset = AngleFailure.offset;
        msg.AngleFailure = *reinterpret_cast<std::decay<decltype(msg.AngleFailure)>::type*>(&AngleFailure.signal);
        msg.AngleFailure = msg.AngleFailure * factor + offset;
        factor = SteeringAngleValidData.factor;
        offset = SteeringAngleValidData.offset;
        msg.SteeringAngleValidData = *reinterpret_cast<std::decay<decltype(msg.SteeringAngleValidData)>::type*>(&SteeringAngleValidData.signal);
        msg.SteeringAngleValidData = msg.SteeringAngleValidData * factor + offset;
        factor = SteeringAngleSpeedValidData.factor;
        offset = SteeringAngleSpeedValidData.offset;
        msg.SteeringAngleSpeedValidData = *reinterpret_cast<std::decay<decltype(msg.SteeringAngleSpeedValidData)>::type*>(&SteeringAngleSpeedValidData.signal);
        msg.SteeringAngleSpeedValidData = msg.SteeringAngleSpeedValidData * factor + offset;
        factor = SAM_1_G_MessageCounter.factor;
        offset = SAM_1_G_MessageCounter.offset;
        msg.SAM_1_G_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.SAM_1_G_MessageCounter)>::type*>(&SAM_1_G_MessageCounter.signal);
        msg.SAM_1_G_MessageCounter = msg.SAM_1_G_MessageCounter * factor + offset;
        factor = SAM_1_GCRCCheck.factor;
        offset = SAM_1_GCRCCheck.offset;
        msg.SAM_1_GCRCCheck = *reinterpret_cast<std::decay<decltype(msg.SAM_1_GCRCCheck)>::type*>(&SAM_1_GCRCCheck.signal);
        msg.SAM_1_GCRCCheck = msg.SAM_1_GCRCCheck * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        SAM_1_G_MSG can_struct;
        CanParser2CanStruct_SAM_1_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::SAM_1_G_MSGMsg>();
        Struct2Proto_SAM_1_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("sam_1_g") != nullptr) {
            DFHLOG_I("sam_1_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("sam_1_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port sam_1_g");
            return false;
         }
    }
};

struct TCU_1_Parser {
    SignalParser TorqueLimitation;

    SignalParser APA_TCU_available;

    SignalParser APA_TCU_DriverIntervention;

    SignalParser TCU_1_MessageCounter;

    SignalParser TCU_1_Checksum;

    TCU_1_Parser() {
        TorqueLimitation = CanConfiguration::Instance().SignalParsers()["TorqueLimitation"];
        APA_TCU_available = CanConfiguration::Instance().SignalParsers()["APA_TCU_available"];
        APA_TCU_DriverIntervention = CanConfiguration::Instance().SignalParsers()["APA_TCU_DriverIntervention"];
        TCU_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["TCU_1_MessageCounter"];
        TCU_1_Checksum = CanConfiguration::Instance().SignalParsers()["TCU_1_Checksum"];
    }

    void Parser(uint8_t* payload){
        TorqueLimitation.Parser(payload);
        APA_TCU_available.Parser(payload);
        APA_TCU_DriverIntervention.Parser(payload);
        TCU_1_MessageCounter.Parser(payload);
        TCU_1_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_TCU_1_MSG(TCU_1_MSG& msg) {
        double factor;
        double offset;
        factor = TorqueLimitation.factor;
        offset = TorqueLimitation.offset;
        msg.TorqueLimitation = *reinterpret_cast<std::decay<decltype(msg.TorqueLimitation)>::type*>(&TorqueLimitation.signal);
        msg.TorqueLimitation = msg.TorqueLimitation * factor + offset;
        factor = APA_TCU_available.factor;
        offset = APA_TCU_available.offset;
        msg.APA_TCU_available = *reinterpret_cast<std::decay<decltype(msg.APA_TCU_available)>::type*>(&APA_TCU_available.signal);
        msg.APA_TCU_available = msg.APA_TCU_available * factor + offset;
        factor = APA_TCU_DriverIntervention.factor;
        offset = APA_TCU_DriverIntervention.offset;
        msg.APA_TCU_DriverIntervention = *reinterpret_cast<std::decay<decltype(msg.APA_TCU_DriverIntervention)>::type*>(&APA_TCU_DriverIntervention.signal);
        msg.APA_TCU_DriverIntervention = msg.APA_TCU_DriverIntervention * factor + offset;
        factor = TCU_1_MessageCounter.factor;
        offset = TCU_1_MessageCounter.offset;
        msg.TCU_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.TCU_1_MessageCounter)>::type*>(&TCU_1_MessageCounter.signal);
        msg.TCU_1_MessageCounter = msg.TCU_1_MessageCounter * factor + offset;
        factor = TCU_1_Checksum.factor;
        offset = TCU_1_Checksum.offset;
        msg.TCU_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.TCU_1_Checksum)>::type*>(&TCU_1_Checksum.signal);
        msg.TCU_1_Checksum = msg.TCU_1_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TCU_1_MSG can_struct;
        CanParser2CanStruct_TCU_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TCU_1_MSGMsg>();
        Struct2Proto_TCU_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tcu_1") != nullptr) {
            DFHLOG_I("tcu_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tcu_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tcu_1");
            return false;
         }
    }
};

struct TCU_2_Parser {
    SignalParser GBPositoionDisplayForPEPS;

    SignalParser ActualGear;

    SignalParser DriverMode;

    SignalParser TargetGearValidData;

    SignalParser ActualGearValidData;

    SignalParser ShiftInProgress;

    SignalParser ShiftInProgressValidData;

    SignalParser TargetGear;

    SignalParser GearRatio;

    SignalParser TCU_2_MessageCounter;

    SignalParser TCU_2_Checksum;

    TCU_2_Parser() {
        GBPositoionDisplayForPEPS = CanConfiguration::Instance().SignalParsers()["GBPositoionDisplayForPEPS"];
        ActualGear = CanConfiguration::Instance().SignalParsers()["ActualGear"];
        DriverMode = CanConfiguration::Instance().SignalParsers()["DriverMode"];
        TargetGearValidData = CanConfiguration::Instance().SignalParsers()["TargetGearValidData"];
        ActualGearValidData = CanConfiguration::Instance().SignalParsers()["ActualGearValidData"];
        ShiftInProgress = CanConfiguration::Instance().SignalParsers()["ShiftInProgress"];
        ShiftInProgressValidData = CanConfiguration::Instance().SignalParsers()["ShiftInProgressValidData"];
        TargetGear = CanConfiguration::Instance().SignalParsers()["TargetGear"];
        GearRatio = CanConfiguration::Instance().SignalParsers()["GearRatio"];
        TCU_2_MessageCounter = CanConfiguration::Instance().SignalParsers()["TCU_2_MessageCounter"];
        TCU_2_Checksum = CanConfiguration::Instance().SignalParsers()["TCU_2_Checksum"];
    }

    void Parser(uint8_t* payload){
        GBPositoionDisplayForPEPS.Parser(payload);
        ActualGear.Parser(payload);
        DriverMode.Parser(payload);
        TargetGearValidData.Parser(payload);
        ActualGearValidData.Parser(payload);
        ShiftInProgress.Parser(payload);
        ShiftInProgressValidData.Parser(payload);
        TargetGear.Parser(payload);
        GearRatio.Parser(payload);
        TCU_2_MessageCounter.Parser(payload);
        TCU_2_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_TCU_2_MSG(TCU_2_MSG& msg) {
        double factor;
        double offset;
        factor = GBPositoionDisplayForPEPS.factor;
        offset = GBPositoionDisplayForPEPS.offset;
        msg.GBPositoionDisplayForPEPS = *reinterpret_cast<std::decay<decltype(msg.GBPositoionDisplayForPEPS)>::type*>(&GBPositoionDisplayForPEPS.signal);
        msg.GBPositoionDisplayForPEPS = msg.GBPositoionDisplayForPEPS * factor + offset;
        factor = ActualGear.factor;
        offset = ActualGear.offset;
        msg.ActualGear = *reinterpret_cast<std::decay<decltype(msg.ActualGear)>::type*>(&ActualGear.signal);
        msg.ActualGear = msg.ActualGear * factor + offset;
        factor = DriverMode.factor;
        offset = DriverMode.offset;
        msg.DriverMode = *reinterpret_cast<std::decay<decltype(msg.DriverMode)>::type*>(&DriverMode.signal);
        msg.DriverMode = msg.DriverMode * factor + offset;
        factor = TargetGearValidData.factor;
        offset = TargetGearValidData.offset;
        msg.TargetGearValidData = *reinterpret_cast<std::decay<decltype(msg.TargetGearValidData)>::type*>(&TargetGearValidData.signal);
        msg.TargetGearValidData = msg.TargetGearValidData * factor + offset;
        factor = ActualGearValidData.factor;
        offset = ActualGearValidData.offset;
        msg.ActualGearValidData = *reinterpret_cast<std::decay<decltype(msg.ActualGearValidData)>::type*>(&ActualGearValidData.signal);
        msg.ActualGearValidData = msg.ActualGearValidData * factor + offset;
        factor = ShiftInProgress.factor;
        offset = ShiftInProgress.offset;
        msg.ShiftInProgress = *reinterpret_cast<std::decay<decltype(msg.ShiftInProgress)>::type*>(&ShiftInProgress.signal);
        msg.ShiftInProgress = msg.ShiftInProgress * factor + offset;
        factor = ShiftInProgressValidData.factor;
        offset = ShiftInProgressValidData.offset;
        msg.ShiftInProgressValidData = *reinterpret_cast<std::decay<decltype(msg.ShiftInProgressValidData)>::type*>(&ShiftInProgressValidData.signal);
        msg.ShiftInProgressValidData = msg.ShiftInProgressValidData * factor + offset;
        factor = TargetGear.factor;
        offset = TargetGear.offset;
        msg.TargetGear = *reinterpret_cast<std::decay<decltype(msg.TargetGear)>::type*>(&TargetGear.signal);
        msg.TargetGear = msg.TargetGear * factor + offset;
        factor = GearRatio.factor;
        offset = GearRatio.offset;
        msg.GearRatio = *reinterpret_cast<std::decay<decltype(msg.GearRatio)>::type*>(&GearRatio.signal);
        msg.GearRatio = msg.GearRatio * factor + offset;
        factor = TCU_2_MessageCounter.factor;
        offset = TCU_2_MessageCounter.offset;
        msg.TCU_2_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.TCU_2_MessageCounter)>::type*>(&TCU_2_MessageCounter.signal);
        msg.TCU_2_MessageCounter = msg.TCU_2_MessageCounter * factor + offset;
        factor = TCU_2_Checksum.factor;
        offset = TCU_2_Checksum.offset;
        msg.TCU_2_Checksum = *reinterpret_cast<std::decay<decltype(msg.TCU_2_Checksum)>::type*>(&TCU_2_Checksum.signal);
        msg.TCU_2_Checksum = msg.TCU_2_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TCU_2_MSG can_struct;
        CanParser2CanStruct_TCU_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TCU_2_MSGMsg>();
        Struct2Proto_TCU_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tcu_2") != nullptr) {
            DFHLOG_I("tcu_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tcu_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tcu_2");
            return false;
         }
    }
};

struct TCU_3_Parser {
    SignalParser IdleControlLoadTorque;

    SignalParser DesiredEngineIdleSpeed;

    SignalParser TCU_3_MessageCounter;

    SignalParser TCU_3_Checksum;

    TCU_3_Parser() {
        IdleControlLoadTorque = CanConfiguration::Instance().SignalParsers()["IdleControlLoadTorque"];
        DesiredEngineIdleSpeed = CanConfiguration::Instance().SignalParsers()["DesiredEngineIdleSpeed"];
        TCU_3_MessageCounter = CanConfiguration::Instance().SignalParsers()["TCU_3_MessageCounter"];
        TCU_3_Checksum = CanConfiguration::Instance().SignalParsers()["TCU_3_Checksum"];
    }

    void Parser(uint8_t* payload){
        IdleControlLoadTorque.Parser(payload);
        DesiredEngineIdleSpeed.Parser(payload);
        TCU_3_MessageCounter.Parser(payload);
        TCU_3_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_TCU_3_MSG(TCU_3_MSG& msg) {
        double factor;
        double offset;
        factor = IdleControlLoadTorque.factor;
        offset = IdleControlLoadTorque.offset;
        msg.IdleControlLoadTorque = *reinterpret_cast<std::decay<decltype(msg.IdleControlLoadTorque)>::type*>(&IdleControlLoadTorque.signal);
        msg.IdleControlLoadTorque = msg.IdleControlLoadTorque * factor + offset;
        factor = DesiredEngineIdleSpeed.factor;
        offset = DesiredEngineIdleSpeed.offset;
        msg.DesiredEngineIdleSpeed = *reinterpret_cast<std::decay<decltype(msg.DesiredEngineIdleSpeed)>::type*>(&DesiredEngineIdleSpeed.signal);
        msg.DesiredEngineIdleSpeed = msg.DesiredEngineIdleSpeed * factor + offset;
        factor = TCU_3_MessageCounter.factor;
        offset = TCU_3_MessageCounter.offset;
        msg.TCU_3_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.TCU_3_MessageCounter)>::type*>(&TCU_3_MessageCounter.signal);
        msg.TCU_3_MessageCounter = msg.TCU_3_MessageCounter * factor + offset;
        factor = TCU_3_Checksum.factor;
        offset = TCU_3_Checksum.offset;
        msg.TCU_3_Checksum = *reinterpret_cast<std::decay<decltype(msg.TCU_3_Checksum)>::type*>(&TCU_3_Checksum.signal);
        msg.TCU_3_Checksum = msg.TCU_3_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TCU_3_MSG can_struct;
        CanParser2CanStruct_TCU_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TCU_3_MSGMsg>();
        Struct2Proto_TCU_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tcu_3") != nullptr) {
            DFHLOG_I("tcu_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tcu_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tcu_3");
            return false;
         }
    }
};

struct TCU_4_Parser {
    SignalParser STAT_LimpHomeMode;

    SignalParser ALIVE_TCU_4;

    SignalParser CRC_TCU_4;

    TCU_4_Parser() {
        STAT_LimpHomeMode = CanConfiguration::Instance().SignalParsers()["STAT_LimpHomeMode"];
        ALIVE_TCU_4 = CanConfiguration::Instance().SignalParsers()["ALIVE_TCU_4"];
        CRC_TCU_4 = CanConfiguration::Instance().SignalParsers()["CRC_TCU_4"];
    }

    void Parser(uint8_t* payload){
        STAT_LimpHomeMode.Parser(payload);
        ALIVE_TCU_4.Parser(payload);
        CRC_TCU_4.Parser(payload);
    }

    void CanParser2CanStruct_TCU_4_MSG(TCU_4_MSG& msg) {
        double factor;
        double offset;
        factor = STAT_LimpHomeMode.factor;
        offset = STAT_LimpHomeMode.offset;
        msg.STAT_LimpHomeMode = *reinterpret_cast<std::decay<decltype(msg.STAT_LimpHomeMode)>::type*>(&STAT_LimpHomeMode.signal);
        msg.STAT_LimpHomeMode = msg.STAT_LimpHomeMode * factor + offset;
        factor = ALIVE_TCU_4.factor;
        offset = ALIVE_TCU_4.offset;
        msg.ALIVE_TCU_4 = *reinterpret_cast<std::decay<decltype(msg.ALIVE_TCU_4)>::type*>(&ALIVE_TCU_4.signal);
        msg.ALIVE_TCU_4 = msg.ALIVE_TCU_4 * factor + offset;
        factor = CRC_TCU_4.factor;
        offset = CRC_TCU_4.offset;
        msg.CRC_TCU_4 = *reinterpret_cast<std::decay<decltype(msg.CRC_TCU_4)>::type*>(&CRC_TCU_4.signal);
        msg.CRC_TCU_4 = msg.CRC_TCU_4 * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TCU_4_MSG can_struct;
        CanParser2CanStruct_TCU_4_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TCU_4_MSGMsg>();
        Struct2Proto_TCU_4_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tcu_4") != nullptr) {
            DFHLOG_I("tcu_4");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tcu_4")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tcu_4");
            return false;
         }
    }
};

struct TCU_G_Parser {
    SignalParser GBPositoionDisplay;

    TCU_G_Parser() {
        GBPositoionDisplay = CanConfiguration::Instance().SignalParsers()["GBPositoionDisplay"];
    }

    void Parser(uint8_t* payload){
        GBPositoionDisplay.Parser(payload);
    }

    void CanParser2CanStruct_TCU_G_MSG(TCU_G_MSG& msg) {
        double factor;
        double offset;
        factor = GBPositoionDisplay.factor;
        offset = GBPositoionDisplay.offset;
        msg.GBPositoionDisplay = *reinterpret_cast<std::decay<decltype(msg.GBPositoionDisplay)>::type*>(&GBPositoionDisplay.signal);
        msg.GBPositoionDisplay = msg.GBPositoionDisplay * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TCU_G_MSG can_struct;
        CanParser2CanStruct_TCU_G_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TCU_G_MSGMsg>();
        Struct2Proto_TCU_G_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tcu_g") != nullptr) {
            DFHLOG_I("tcu_g");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tcu_g")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tcu_g");
            return false;
         }
    }
};

struct TBOX_2_Parser {
    SignalParser TBOX_SetAVMOnReq;

    SignalParser TBOX_SetAVMVeiw;

    TBOX_2_Parser() {
        TBOX_SetAVMOnReq = CanConfiguration::Instance().SignalParsers()["TBOX_SetAVMOnReq"];
        TBOX_SetAVMVeiw = CanConfiguration::Instance().SignalParsers()["TBOX_SetAVMVeiw"];
    }

    void Parser(uint8_t* payload){
        TBOX_SetAVMOnReq.Parser(payload);
        TBOX_SetAVMVeiw.Parser(payload);
    }

    void CanParser2CanStruct_TBOX_2_MSG(TBOX_2_MSG& msg) {
        double factor;
        double offset;
        factor = TBOX_SetAVMOnReq.factor;
        offset = TBOX_SetAVMOnReq.offset;
        msg.TBOX_SetAVMOnReq = *reinterpret_cast<std::decay<decltype(msg.TBOX_SetAVMOnReq)>::type*>(&TBOX_SetAVMOnReq.signal);
        msg.TBOX_SetAVMOnReq = msg.TBOX_SetAVMOnReq * factor + offset;
        factor = TBOX_SetAVMVeiw.factor;
        offset = TBOX_SetAVMVeiw.offset;
        msg.TBOX_SetAVMVeiw = *reinterpret_cast<std::decay<decltype(msg.TBOX_SetAVMVeiw)>::type*>(&TBOX_SetAVMVeiw.signal);
        msg.TBOX_SetAVMVeiw = msg.TBOX_SetAVMVeiw * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TBOX_2_MSG can_struct;
        CanParser2CanStruct_TBOX_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TBOX_2_MSGMsg>();
        Struct2Proto_TBOX_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tbox_2") != nullptr) {
            DFHLOG_I("tbox_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tbox_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tbox_2");
            return false;
         }
    }
};

struct TBOX_6_Parser {
    SignalParser TBOX_6_AVPFctLinkSts;

    SignalParser TBOX_6_ParkOutDirReq;

    SignalParser TBOX_6_ParkEntReq;

    SignalParser TBOX_6_ParkFrntEna;

    SignalParser TBOX_6_ParkBacktEna;

    SignalParser TBOX_6_AVPFctReq;

    SignalParser TBOX_6_AVPActv;

    SignalParser TBOX_6_MessageCounter;

    SignalParser TBOX_6_ParkOutDirectionSt;

    SignalParser TBOX_6_PhoneDevicefailSts;

    SignalParser TBOX_6_RpaModReq;

    SignalParser TBOX_6_BluetoothErrorSts;

    SignalParser TBOX_6_Checksum;

    TBOX_6_Parser() {
        TBOX_6_AVPFctLinkSts = CanConfiguration::Instance().SignalParsers()["TBOX_6_AVPFctLinkSts"];
        TBOX_6_ParkOutDirReq = CanConfiguration::Instance().SignalParsers()["TBOX_6_ParkOutDirReq"];
        TBOX_6_ParkEntReq = CanConfiguration::Instance().SignalParsers()["TBOX_6_ParkEntReq"];
        TBOX_6_ParkFrntEna = CanConfiguration::Instance().SignalParsers()["TBOX_6_ParkFrntEna"];
        TBOX_6_ParkBacktEna = CanConfiguration::Instance().SignalParsers()["TBOX_6_ParkBacktEna"];
        TBOX_6_AVPFctReq = CanConfiguration::Instance().SignalParsers()["TBOX_6_AVPFctReq"];
        TBOX_6_AVPActv = CanConfiguration::Instance().SignalParsers()["TBOX_6_AVPActv"];
        TBOX_6_MessageCounter = CanConfiguration::Instance().SignalParsers()["TBOX_6_MessageCounter"];
        TBOX_6_ParkOutDirectionSt = CanConfiguration::Instance().SignalParsers()["TBOX_6_ParkOutDirectionSt"];
        TBOX_6_PhoneDevicefailSts = CanConfiguration::Instance().SignalParsers()["TBOX_6_PhoneDevicefailSts"];
        TBOX_6_RpaModReq = CanConfiguration::Instance().SignalParsers()["TBOX_6_RpaModReq"];
        TBOX_6_BluetoothErrorSts = CanConfiguration::Instance().SignalParsers()["TBOX_6_BluetoothErrorSts"];
        TBOX_6_Checksum = CanConfiguration::Instance().SignalParsers()["TBOX_6_Checksum"];
    }

    void Parser(uint8_t* payload){
        TBOX_6_AVPFctLinkSts.Parser(payload);
        TBOX_6_ParkOutDirReq.Parser(payload);
        TBOX_6_ParkEntReq.Parser(payload);
        TBOX_6_ParkFrntEna.Parser(payload);
        TBOX_6_ParkBacktEna.Parser(payload);
        TBOX_6_AVPFctReq.Parser(payload);
        TBOX_6_AVPActv.Parser(payload);
        TBOX_6_MessageCounter.Parser(payload);
        TBOX_6_ParkOutDirectionSt.Parser(payload);
        TBOX_6_PhoneDevicefailSts.Parser(payload);
        TBOX_6_RpaModReq.Parser(payload);
        TBOX_6_BluetoothErrorSts.Parser(payload);
        TBOX_6_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_TBOX_6_MSG(TBOX_6_MSG& msg) {
        double factor;
        double offset;
        factor = TBOX_6_AVPFctLinkSts.factor;
        offset = TBOX_6_AVPFctLinkSts.offset;
        msg.TBOX_6_AVPFctLinkSts = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_AVPFctLinkSts)>::type*>(&TBOX_6_AVPFctLinkSts.signal);
        msg.TBOX_6_AVPFctLinkSts = msg.TBOX_6_AVPFctLinkSts * factor + offset;
        factor = TBOX_6_ParkOutDirReq.factor;
        offset = TBOX_6_ParkOutDirReq.offset;
        msg.TBOX_6_ParkOutDirReq = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_ParkOutDirReq)>::type*>(&TBOX_6_ParkOutDirReq.signal);
        msg.TBOX_6_ParkOutDirReq = msg.TBOX_6_ParkOutDirReq * factor + offset;
        factor = TBOX_6_ParkEntReq.factor;
        offset = TBOX_6_ParkEntReq.offset;
        msg.TBOX_6_ParkEntReq = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_ParkEntReq)>::type*>(&TBOX_6_ParkEntReq.signal);
        msg.TBOX_6_ParkEntReq = msg.TBOX_6_ParkEntReq * factor + offset;
        factor = TBOX_6_ParkFrntEna.factor;
        offset = TBOX_6_ParkFrntEna.offset;
        msg.TBOX_6_ParkFrntEna = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_ParkFrntEna)>::type*>(&TBOX_6_ParkFrntEna.signal);
        msg.TBOX_6_ParkFrntEna = msg.TBOX_6_ParkFrntEna * factor + offset;
        factor = TBOX_6_ParkBacktEna.factor;
        offset = TBOX_6_ParkBacktEna.offset;
        msg.TBOX_6_ParkBacktEna = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_ParkBacktEna)>::type*>(&TBOX_6_ParkBacktEna.signal);
        msg.TBOX_6_ParkBacktEna = msg.TBOX_6_ParkBacktEna * factor + offset;
        factor = TBOX_6_AVPFctReq.factor;
        offset = TBOX_6_AVPFctReq.offset;
        msg.TBOX_6_AVPFctReq = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_AVPFctReq)>::type*>(&TBOX_6_AVPFctReq.signal);
        msg.TBOX_6_AVPFctReq = msg.TBOX_6_AVPFctReq * factor + offset;
        factor = TBOX_6_AVPActv.factor;
        offset = TBOX_6_AVPActv.offset;
        msg.TBOX_6_AVPActv = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_AVPActv)>::type*>(&TBOX_6_AVPActv.signal);
        msg.TBOX_6_AVPActv = msg.TBOX_6_AVPActv * factor + offset;
        factor = TBOX_6_MessageCounter.factor;
        offset = TBOX_6_MessageCounter.offset;
        msg.TBOX_6_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_MessageCounter)>::type*>(&TBOX_6_MessageCounter.signal);
        msg.TBOX_6_MessageCounter = msg.TBOX_6_MessageCounter * factor + offset;
        factor = TBOX_6_ParkOutDirectionSt.factor;
        offset = TBOX_6_ParkOutDirectionSt.offset;
        msg.TBOX_6_ParkOutDirectionSt = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_ParkOutDirectionSt)>::type*>(&TBOX_6_ParkOutDirectionSt.signal);
        msg.TBOX_6_ParkOutDirectionSt = msg.TBOX_6_ParkOutDirectionSt * factor + offset;
        factor = TBOX_6_PhoneDevicefailSts.factor;
        offset = TBOX_6_PhoneDevicefailSts.offset;
        msg.TBOX_6_PhoneDevicefailSts = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_PhoneDevicefailSts)>::type*>(&TBOX_6_PhoneDevicefailSts.signal);
        msg.TBOX_6_PhoneDevicefailSts = msg.TBOX_6_PhoneDevicefailSts * factor + offset;
        factor = TBOX_6_RpaModReq.factor;
        offset = TBOX_6_RpaModReq.offset;
        msg.TBOX_6_RpaModReq = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_RpaModReq)>::type*>(&TBOX_6_RpaModReq.signal);
        msg.TBOX_6_RpaModReq = msg.TBOX_6_RpaModReq * factor + offset;
        factor = TBOX_6_BluetoothErrorSts.factor;
        offset = TBOX_6_BluetoothErrorSts.offset;
        msg.TBOX_6_BluetoothErrorSts = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_BluetoothErrorSts)>::type*>(&TBOX_6_BluetoothErrorSts.signal);
        msg.TBOX_6_BluetoothErrorSts = msg.TBOX_6_BluetoothErrorSts * factor + offset;
        factor = TBOX_6_Checksum.factor;
        offset = TBOX_6_Checksum.offset;
        msg.TBOX_6_Checksum = *reinterpret_cast<std::decay<decltype(msg.TBOX_6_Checksum)>::type*>(&TBOX_6_Checksum.signal);
        msg.TBOX_6_Checksum = msg.TBOX_6_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        TBOX_6_MSG can_struct;
        CanParser2CanStruct_TBOX_6_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::TBOX_6_MSGMsg>();
        Struct2Proto_TBOX_6_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("tbox_6") != nullptr) {
            DFHLOG_I("tbox_6");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("tbox_6")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port tbox_6");
            return false;
         }
    }
};

struct IHU_1_Parser {
    SignalParser LanguageSet;

    SignalParser RRMResolutionX;

    SignalParser RRMResolutionY;

    IHU_1_Parser() {
        LanguageSet = CanConfiguration::Instance().SignalParsers()["LanguageSet"];
        RRMResolutionX = CanConfiguration::Instance().SignalParsers()["RRMResolutionX"];
        RRMResolutionY = CanConfiguration::Instance().SignalParsers()["RRMResolutionY"];
    }

    void Parser(uint8_t* payload){
        LanguageSet.Parser(payload);
        RRMResolutionX.Parser(payload);
        RRMResolutionY.Parser(payload);
    }

    void CanParser2CanStruct_IHU_1_MSG(IHU_1_MSG& msg) {
        double factor;
        double offset;
        factor = LanguageSet.factor;
        offset = LanguageSet.offset;
        msg.LanguageSet = *reinterpret_cast<std::decay<decltype(msg.LanguageSet)>::type*>(&LanguageSet.signal);
        msg.LanguageSet = msg.LanguageSet * factor + offset;
        factor = RRMResolutionX.factor;
        offset = RRMResolutionX.offset;
        msg.RRMResolutionX = *reinterpret_cast<std::decay<decltype(msg.RRMResolutionX)>::type*>(&RRMResolutionX.signal);
        msg.RRMResolutionX = msg.RRMResolutionX * factor + offset;
        factor = RRMResolutionY.factor;
        offset = RRMResolutionY.offset;
        msg.RRMResolutionY = *reinterpret_cast<std::decay<decltype(msg.RRMResolutionY)>::type*>(&RRMResolutionY.signal);
        msg.RRMResolutionY = msg.RRMResolutionY * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_1_MSG can_struct;
        CanParser2CanStruct_IHU_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_1_MSGMsg>();
        Struct2Proto_IHU_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_1") != nullptr) {
            DFHLOG_I("ihu_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_1");
            return false;
         }
    }
};

struct IHU_7_Parser {
    SignalParser IHU_7_CPONOFF;

    SignalParser IHU_7_NOCONOFFsts;

    SignalParser IHU_7_ALCDrvrCfmONOFFsts;

    SignalParser IHU_7_ALCDrvSty;

    SignalParser IHU_7_DCLCONOFF;

    SignalParser IHU_7_DrvAssiStyle;

    IHU_7_Parser() {
        IHU_7_CPONOFF = CanConfiguration::Instance().SignalParsers()["IHU_7_CPONOFF"];
        IHU_7_NOCONOFFsts = CanConfiguration::Instance().SignalParsers()["IHU_7_NOCONOFFsts"];
        IHU_7_ALCDrvrCfmONOFFsts = CanConfiguration::Instance().SignalParsers()["IHU_7_ALCDrvrCfmONOFFsts"];
        IHU_7_ALCDrvSty = CanConfiguration::Instance().SignalParsers()["IHU_7_ALCDrvSty"];
        IHU_7_DCLCONOFF = CanConfiguration::Instance().SignalParsers()["IHU_7_DCLCONOFF"];
        IHU_7_DrvAssiStyle = CanConfiguration::Instance().SignalParsers()["IHU_7_DrvAssiStyle"];
    }

    void Parser(uint8_t* payload){
        IHU_7_CPONOFF.Parser(payload);
        IHU_7_NOCONOFFsts.Parser(payload);
        IHU_7_ALCDrvrCfmONOFFsts.Parser(payload);
        IHU_7_ALCDrvSty.Parser(payload);
        IHU_7_DCLCONOFF.Parser(payload);
        IHU_7_DrvAssiStyle.Parser(payload);
    }

    void CanParser2CanStruct_IHU_7_MSG(IHU_7_MSG& msg) {
        double factor;
        double offset;
        factor = IHU_7_CPONOFF.factor;
        offset = IHU_7_CPONOFF.offset;
        msg.IHU_7_CPONOFF = *reinterpret_cast<std::decay<decltype(msg.IHU_7_CPONOFF)>::type*>(&IHU_7_CPONOFF.signal);
        msg.IHU_7_CPONOFF = msg.IHU_7_CPONOFF * factor + offset;
        factor = IHU_7_NOCONOFFsts.factor;
        offset = IHU_7_NOCONOFFsts.offset;
        msg.IHU_7_NOCONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IHU_7_NOCONOFFsts)>::type*>(&IHU_7_NOCONOFFsts.signal);
        msg.IHU_7_NOCONOFFsts = msg.IHU_7_NOCONOFFsts * factor + offset;
        factor = IHU_7_ALCDrvrCfmONOFFsts.factor;
        offset = IHU_7_ALCDrvrCfmONOFFsts.offset;
        msg.IHU_7_ALCDrvrCfmONOFFsts = *reinterpret_cast<std::decay<decltype(msg.IHU_7_ALCDrvrCfmONOFFsts)>::type*>(&IHU_7_ALCDrvrCfmONOFFsts.signal);
        msg.IHU_7_ALCDrvrCfmONOFFsts = msg.IHU_7_ALCDrvrCfmONOFFsts * factor + offset;
        factor = IHU_7_ALCDrvSty.factor;
        offset = IHU_7_ALCDrvSty.offset;
        msg.IHU_7_ALCDrvSty = *reinterpret_cast<std::decay<decltype(msg.IHU_7_ALCDrvSty)>::type*>(&IHU_7_ALCDrvSty.signal);
        msg.IHU_7_ALCDrvSty = msg.IHU_7_ALCDrvSty * factor + offset;
        factor = IHU_7_DCLCONOFF.factor;
        offset = IHU_7_DCLCONOFF.offset;
        msg.IHU_7_DCLCONOFF = *reinterpret_cast<std::decay<decltype(msg.IHU_7_DCLCONOFF)>::type*>(&IHU_7_DCLCONOFF.signal);
        msg.IHU_7_DCLCONOFF = msg.IHU_7_DCLCONOFF * factor + offset;
        factor = IHU_7_DrvAssiStyle.factor;
        offset = IHU_7_DrvAssiStyle.offset;
        msg.IHU_7_DrvAssiStyle = *reinterpret_cast<std::decay<decltype(msg.IHU_7_DrvAssiStyle)>::type*>(&IHU_7_DrvAssiStyle.signal);
        msg.IHU_7_DrvAssiStyle = msg.IHU_7_DrvAssiStyle * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_7_MSG can_struct;
        CanParser2CanStruct_IHU_7_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_7_MSGMsg>();
        Struct2Proto_IHU_7_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_7") != nullptr) {
            DFHLOG_I("ihu_7");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_7")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_7");
            return false;
         }
    }
};

struct IHU_3_Parser {
    SignalParser DVD_SetThemeType;

    IHU_3_Parser() {
        DVD_SetThemeType = CanConfiguration::Instance().SignalParsers()["DVD_SetThemeType"];
    }

    void Parser(uint8_t* payload){
        DVD_SetThemeType.Parser(payload);
    }

    void CanParser2CanStruct_IHU_3_MSG(IHU_3_MSG& msg) {
        double factor;
        double offset;
        factor = DVD_SetThemeType.factor;
        offset = DVD_SetThemeType.offset;
        msg.DVD_SetThemeType = *reinterpret_cast<std::decay<decltype(msg.DVD_SetThemeType)>::type*>(&DVD_SetThemeType.signal);
        msg.DVD_SetThemeType = msg.DVD_SetThemeType * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_3_MSG can_struct;
        CanParser2CanStruct_IHU_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_3_MSGMsg>();
        Struct2Proto_IHU_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_3") != nullptr) {
            DFHLOG_I("ihu_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_3");
            return false;
         }
    }
};

struct IHU_8_Parser {
    SignalParser Set_Default;

    IHU_8_Parser() {
        Set_Default = CanConfiguration::Instance().SignalParsers()["Set_Default"];
    }

    void Parser(uint8_t* payload){
        Set_Default.Parser(payload);
    }

    void CanParser2CanStruct_IHU_8_MSG(IHU_8_MSG& msg) {
        double factor;
        double offset;
        factor = Set_Default.factor;
        offset = Set_Default.offset;
        msg.Set_Default = *reinterpret_cast<std::decay<decltype(msg.Set_Default)>::type*>(&Set_Default.signal);
        msg.Set_Default = msg.Set_Default * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_8_MSG can_struct;
        CanParser2CanStruct_IHU_8_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_8_MSGMsg>();
        Struct2Proto_IHU_8_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_8") != nullptr) {
            DFHLOG_I("ihu_8");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_8")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_8");
            return false;
         }
    }
};

struct IHU_9_Parser {
    SignalParser IHU_9_FrntRadarSwt;

    IHU_9_Parser() {
        IHU_9_FrntRadarSwt = CanConfiguration::Instance().SignalParsers()["IHU_9_FrntRadarSwt"];
    }

    void Parser(uint8_t* payload){
        IHU_9_FrntRadarSwt.Parser(payload);
    }

    void CanParser2CanStruct_IHU_9_MSG(IHU_9_MSG& msg) {
        double factor;
        double offset;
        factor = IHU_9_FrntRadarSwt.factor;
        offset = IHU_9_FrntRadarSwt.offset;
        msg.IHU_9_FrntRadarSwt = *reinterpret_cast<std::decay<decltype(msg.IHU_9_FrntRadarSwt)>::type*>(&IHU_9_FrntRadarSwt.signal);
        msg.IHU_9_FrntRadarSwt = msg.IHU_9_FrntRadarSwt * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_9_MSG can_struct;
        CanParser2CanStruct_IHU_9_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_9_MSGMsg>();
        Struct2Proto_IHU_9_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_9") != nullptr) {
            DFHLOG_I("ihu_9");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_9")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_9");
            return false;
         }
    }
};

struct IHU_10_Parser {
    SignalParser NavSpeedLimitStatus;

    SignalParser NavSpeedLimit;

    SignalParser NavSpeedLimitUnits;

    SignalParser NavCurrRoadType;

    SignalParser IHU_DriveMode;

    SignalParser IHU_10_Displaysts;

    IHU_10_Parser() {
        NavSpeedLimitStatus = CanConfiguration::Instance().SignalParsers()["NavSpeedLimitStatus"];
        NavSpeedLimit = CanConfiguration::Instance().SignalParsers()["NavSpeedLimit"];
        NavSpeedLimitUnits = CanConfiguration::Instance().SignalParsers()["NavSpeedLimitUnits"];
        NavCurrRoadType = CanConfiguration::Instance().SignalParsers()["NavCurrRoadType"];
        IHU_DriveMode = CanConfiguration::Instance().SignalParsers()["IHU_DriveMode"];
        IHU_10_Displaysts = CanConfiguration::Instance().SignalParsers()["IHU_10_Displaysts"];
    }

    void Parser(uint8_t* payload){
        NavSpeedLimitStatus.Parser(payload);
        NavSpeedLimit.Parser(payload);
        NavSpeedLimitUnits.Parser(payload);
        NavCurrRoadType.Parser(payload);
        IHU_DriveMode.Parser(payload);
        IHU_10_Displaysts.Parser(payload);
    }

    void CanParser2CanStruct_IHU_10_MSG(IHU_10_MSG& msg) {
        double factor;
        double offset;
        factor = NavSpeedLimitStatus.factor;
        offset = NavSpeedLimitStatus.offset;
        msg.NavSpeedLimitStatus = *reinterpret_cast<std::decay<decltype(msg.NavSpeedLimitStatus)>::type*>(&NavSpeedLimitStatus.signal);
        msg.NavSpeedLimitStatus = msg.NavSpeedLimitStatus * factor + offset;
        factor = NavSpeedLimit.factor;
        offset = NavSpeedLimit.offset;
        msg.NavSpeedLimit = *reinterpret_cast<std::decay<decltype(msg.NavSpeedLimit)>::type*>(&NavSpeedLimit.signal);
        msg.NavSpeedLimit = msg.NavSpeedLimit * factor + offset;
        factor = NavSpeedLimitUnits.factor;
        offset = NavSpeedLimitUnits.offset;
        msg.NavSpeedLimitUnits = *reinterpret_cast<std::decay<decltype(msg.NavSpeedLimitUnits)>::type*>(&NavSpeedLimitUnits.signal);
        msg.NavSpeedLimitUnits = msg.NavSpeedLimitUnits * factor + offset;
        factor = NavCurrRoadType.factor;
        offset = NavCurrRoadType.offset;
        msg.NavCurrRoadType = *reinterpret_cast<std::decay<decltype(msg.NavCurrRoadType)>::type*>(&NavCurrRoadType.signal);
        msg.NavCurrRoadType = msg.NavCurrRoadType * factor + offset;
        factor = IHU_DriveMode.factor;
        offset = IHU_DriveMode.offset;
        msg.IHU_DriveMode = *reinterpret_cast<std::decay<decltype(msg.IHU_DriveMode)>::type*>(&IHU_DriveMode.signal);
        msg.IHU_DriveMode = msg.IHU_DriveMode * factor + offset;
        factor = IHU_10_Displaysts.factor;
        offset = IHU_10_Displaysts.offset;
        msg.IHU_10_Displaysts = *reinterpret_cast<std::decay<decltype(msg.IHU_10_Displaysts)>::type*>(&IHU_10_Displaysts.signal);
        msg.IHU_10_Displaysts = msg.IHU_10_Displaysts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_10_MSG can_struct;
        CanParser2CanStruct_IHU_10_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_10_MSGMsg>();
        Struct2Proto_IHU_10_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_10") != nullptr) {
            DFHLOG_I("ihu_10");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_10")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_10");
            return false;
         }
    }
};

struct IHU_11_Parser {
    SignalParser DVD_SET_DOW;

    SignalParser DVD_SET_RCW;

    SignalParser IHU_11_BSDSwitchSts;

    SignalParser IHU_11_RAEBSwtSet;

    SignalParser IHU_11_RCTBSwtSet;

    SignalParser IHU_11_AEBSwtSet;

    SignalParser IHU_11_FCWSnvtySet;

    SignalParser IHU_11_FCWSwtSet;

    SignalParser IHU_11_TJAICAExitTextInfoSwtSet;

    SignalParser IHU_11_SLASwtSet;

    SignalParser IHU_11_SCFSwtSet;

    SignalParser IHU_11_FCTBSwtSet;

    SignalParser IHU_11_DAISwtSet;

    SignalParser IHU_11_IESSwtSet;

    SignalParser IHU_11_HMASwtSet;

    SignalParser IHU_11_TSISwtSet;

    SignalParser IHU_11_TLISwtSet;

    SignalParser IHU_11_LDWSwtSet;

    SignalParser IHU_11_WarnModSwtSet;

    SignalParser IHU_11_LDPSwtSet;

    SignalParser IHU_11_LDWLDPSnvtySet;

    SignalParser IHU_11_ELKSwtSet;

    IHU_11_Parser() {
        DVD_SET_DOW = CanConfiguration::Instance().SignalParsers()["DVD_SET_DOW"];
        DVD_SET_RCW = CanConfiguration::Instance().SignalParsers()["DVD_SET_RCW"];
        IHU_11_BSDSwitchSts = CanConfiguration::Instance().SignalParsers()["IHU_11_BSDSwitchSts"];
        IHU_11_RAEBSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_RAEBSwtSet"];
        IHU_11_RCTBSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_RCTBSwtSet"];
        IHU_11_AEBSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_AEBSwtSet"];
        IHU_11_FCWSnvtySet = CanConfiguration::Instance().SignalParsers()["IHU_11_FCWSnvtySet"];
        IHU_11_FCWSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_FCWSwtSet"];
        IHU_11_TJAICAExitTextInfoSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_TJAICAExitTextInfoSwtSet"];
        IHU_11_SLASwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_SLASwtSet"];
        IHU_11_SCFSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_SCFSwtSet"];
        IHU_11_FCTBSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_FCTBSwtSet"];
        IHU_11_DAISwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_DAISwtSet"];
        IHU_11_IESSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_IESSwtSet"];
        IHU_11_HMASwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_HMASwtSet"];
        IHU_11_TSISwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_TSISwtSet"];
        IHU_11_TLISwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_TLISwtSet"];
        IHU_11_LDWSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_LDWSwtSet"];
        IHU_11_WarnModSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_WarnModSwtSet"];
        IHU_11_LDPSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_LDPSwtSet"];
        IHU_11_LDWLDPSnvtySet = CanConfiguration::Instance().SignalParsers()["IHU_11_LDWLDPSnvtySet"];
        IHU_11_ELKSwtSet = CanConfiguration::Instance().SignalParsers()["IHU_11_ELKSwtSet"];
    }

    void Parser(uint8_t* payload){
        DVD_SET_DOW.Parser(payload);
        DVD_SET_RCW.Parser(payload);
        IHU_11_BSDSwitchSts.Parser(payload);
        IHU_11_RAEBSwtSet.Parser(payload);
        IHU_11_RCTBSwtSet.Parser(payload);
        IHU_11_AEBSwtSet.Parser(payload);
        IHU_11_FCWSnvtySet.Parser(payload);
        IHU_11_FCWSwtSet.Parser(payload);
        IHU_11_TJAICAExitTextInfoSwtSet.Parser(payload);
        IHU_11_SLASwtSet.Parser(payload);
        IHU_11_SCFSwtSet.Parser(payload);
        IHU_11_FCTBSwtSet.Parser(payload);
        IHU_11_DAISwtSet.Parser(payload);
        IHU_11_IESSwtSet.Parser(payload);
        IHU_11_HMASwtSet.Parser(payload);
        IHU_11_TSISwtSet.Parser(payload);
        IHU_11_TLISwtSet.Parser(payload);
        IHU_11_LDWSwtSet.Parser(payload);
        IHU_11_WarnModSwtSet.Parser(payload);
        IHU_11_LDPSwtSet.Parser(payload);
        IHU_11_LDWLDPSnvtySet.Parser(payload);
        IHU_11_ELKSwtSet.Parser(payload);
    }

    void CanParser2CanStruct_IHU_11_MSG(IHU_11_MSG& msg) {
        double factor;
        double offset;
        factor = DVD_SET_DOW.factor;
        offset = DVD_SET_DOW.offset;
        msg.DVD_SET_DOW = *reinterpret_cast<std::decay<decltype(msg.DVD_SET_DOW)>::type*>(&DVD_SET_DOW.signal);
        msg.DVD_SET_DOW = msg.DVD_SET_DOW * factor + offset;
        factor = DVD_SET_RCW.factor;
        offset = DVD_SET_RCW.offset;
        msg.DVD_SET_RCW = *reinterpret_cast<std::decay<decltype(msg.DVD_SET_RCW)>::type*>(&DVD_SET_RCW.signal);
        msg.DVD_SET_RCW = msg.DVD_SET_RCW * factor + offset;
        factor = IHU_11_BSDSwitchSts.factor;
        offset = IHU_11_BSDSwitchSts.offset;
        msg.IHU_11_BSDSwitchSts = *reinterpret_cast<std::decay<decltype(msg.IHU_11_BSDSwitchSts)>::type*>(&IHU_11_BSDSwitchSts.signal);
        msg.IHU_11_BSDSwitchSts = msg.IHU_11_BSDSwitchSts * factor + offset;
        factor = IHU_11_RAEBSwtSet.factor;
        offset = IHU_11_RAEBSwtSet.offset;
        msg.IHU_11_RAEBSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_RAEBSwtSet)>::type*>(&IHU_11_RAEBSwtSet.signal);
        msg.IHU_11_RAEBSwtSet = msg.IHU_11_RAEBSwtSet * factor + offset;
        factor = IHU_11_RCTBSwtSet.factor;
        offset = IHU_11_RCTBSwtSet.offset;
        msg.IHU_11_RCTBSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_RCTBSwtSet)>::type*>(&IHU_11_RCTBSwtSet.signal);
        msg.IHU_11_RCTBSwtSet = msg.IHU_11_RCTBSwtSet * factor + offset;
        factor = IHU_11_AEBSwtSet.factor;
        offset = IHU_11_AEBSwtSet.offset;
        msg.IHU_11_AEBSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_AEBSwtSet)>::type*>(&IHU_11_AEBSwtSet.signal);
        msg.IHU_11_AEBSwtSet = msg.IHU_11_AEBSwtSet * factor + offset;
        factor = IHU_11_FCWSnvtySet.factor;
        offset = IHU_11_FCWSnvtySet.offset;
        msg.IHU_11_FCWSnvtySet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_FCWSnvtySet)>::type*>(&IHU_11_FCWSnvtySet.signal);
        msg.IHU_11_FCWSnvtySet = msg.IHU_11_FCWSnvtySet * factor + offset;
        factor = IHU_11_FCWSwtSet.factor;
        offset = IHU_11_FCWSwtSet.offset;
        msg.IHU_11_FCWSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_FCWSwtSet)>::type*>(&IHU_11_FCWSwtSet.signal);
        msg.IHU_11_FCWSwtSet = msg.IHU_11_FCWSwtSet * factor + offset;
        factor = IHU_11_TJAICAExitTextInfoSwtSet.factor;
        offset = IHU_11_TJAICAExitTextInfoSwtSet.offset;
        msg.IHU_11_TJAICAExitTextInfoSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_TJAICAExitTextInfoSwtSet)>::type*>(&IHU_11_TJAICAExitTextInfoSwtSet.signal);
        msg.IHU_11_TJAICAExitTextInfoSwtSet = msg.IHU_11_TJAICAExitTextInfoSwtSet * factor + offset;
        factor = IHU_11_SLASwtSet.factor;
        offset = IHU_11_SLASwtSet.offset;
        msg.IHU_11_SLASwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_SLASwtSet)>::type*>(&IHU_11_SLASwtSet.signal);
        msg.IHU_11_SLASwtSet = msg.IHU_11_SLASwtSet * factor + offset;
        factor = IHU_11_SCFSwtSet.factor;
        offset = IHU_11_SCFSwtSet.offset;
        msg.IHU_11_SCFSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_SCFSwtSet)>::type*>(&IHU_11_SCFSwtSet.signal);
        msg.IHU_11_SCFSwtSet = msg.IHU_11_SCFSwtSet * factor + offset;
        factor = IHU_11_FCTBSwtSet.factor;
        offset = IHU_11_FCTBSwtSet.offset;
        msg.IHU_11_FCTBSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_FCTBSwtSet)>::type*>(&IHU_11_FCTBSwtSet.signal);
        msg.IHU_11_FCTBSwtSet = msg.IHU_11_FCTBSwtSet * factor + offset;
        factor = IHU_11_DAISwtSet.factor;
        offset = IHU_11_DAISwtSet.offset;
        msg.IHU_11_DAISwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_DAISwtSet)>::type*>(&IHU_11_DAISwtSet.signal);
        msg.IHU_11_DAISwtSet = msg.IHU_11_DAISwtSet * factor + offset;
        factor = IHU_11_IESSwtSet.factor;
        offset = IHU_11_IESSwtSet.offset;
        msg.IHU_11_IESSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_IESSwtSet)>::type*>(&IHU_11_IESSwtSet.signal);
        msg.IHU_11_IESSwtSet = msg.IHU_11_IESSwtSet * factor + offset;
        factor = IHU_11_HMASwtSet.factor;
        offset = IHU_11_HMASwtSet.offset;
        msg.IHU_11_HMASwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_HMASwtSet)>::type*>(&IHU_11_HMASwtSet.signal);
        msg.IHU_11_HMASwtSet = msg.IHU_11_HMASwtSet * factor + offset;
        factor = IHU_11_TSISwtSet.factor;
        offset = IHU_11_TSISwtSet.offset;
        msg.IHU_11_TSISwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_TSISwtSet)>::type*>(&IHU_11_TSISwtSet.signal);
        msg.IHU_11_TSISwtSet = msg.IHU_11_TSISwtSet * factor + offset;
        factor = IHU_11_TLISwtSet.factor;
        offset = IHU_11_TLISwtSet.offset;
        msg.IHU_11_TLISwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_TLISwtSet)>::type*>(&IHU_11_TLISwtSet.signal);
        msg.IHU_11_TLISwtSet = msg.IHU_11_TLISwtSet * factor + offset;
        factor = IHU_11_LDWSwtSet.factor;
        offset = IHU_11_LDWSwtSet.offset;
        msg.IHU_11_LDWSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_LDWSwtSet)>::type*>(&IHU_11_LDWSwtSet.signal);
        msg.IHU_11_LDWSwtSet = msg.IHU_11_LDWSwtSet * factor + offset;
        factor = IHU_11_WarnModSwtSet.factor;
        offset = IHU_11_WarnModSwtSet.offset;
        msg.IHU_11_WarnModSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_WarnModSwtSet)>::type*>(&IHU_11_WarnModSwtSet.signal);
        msg.IHU_11_WarnModSwtSet = msg.IHU_11_WarnModSwtSet * factor + offset;
        factor = IHU_11_LDPSwtSet.factor;
        offset = IHU_11_LDPSwtSet.offset;
        msg.IHU_11_LDPSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_LDPSwtSet)>::type*>(&IHU_11_LDPSwtSet.signal);
        msg.IHU_11_LDPSwtSet = msg.IHU_11_LDPSwtSet * factor + offset;
        factor = IHU_11_LDWLDPSnvtySet.factor;
        offset = IHU_11_LDWLDPSnvtySet.offset;
        msg.IHU_11_LDWLDPSnvtySet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_LDWLDPSnvtySet)>::type*>(&IHU_11_LDWLDPSnvtySet.signal);
        msg.IHU_11_LDWLDPSnvtySet = msg.IHU_11_LDWLDPSnvtySet * factor + offset;
        factor = IHU_11_ELKSwtSet.factor;
        offset = IHU_11_ELKSwtSet.offset;
        msg.IHU_11_ELKSwtSet = *reinterpret_cast<std::decay<decltype(msg.IHU_11_ELKSwtSet)>::type*>(&IHU_11_ELKSwtSet.signal);
        msg.IHU_11_ELKSwtSet = msg.IHU_11_ELKSwtSet * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_11_MSG can_struct;
        CanParser2CanStruct_IHU_11_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_11_MSGMsg>();
        Struct2Proto_IHU_11_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_11") != nullptr) {
            DFHLOG_I("ihu_11");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_11")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_11");
            return false;
         }
    }
};

struct IHU_12_Parser {
    SignalParser NaviBtnPressInputValueX;

    SignalParser NaviBtnPressInputValueY;

    SignalParser RRMDisplayAVMOff;

    SignalParser CalibrationReq;

    SignalParser IHU_12_CarMdlSetColor;

    SignalParser IHU_APAKeySts;

    SignalParser AVMSwt;

    SignalParser TouchEvt;

    IHU_12_Parser() {
        NaviBtnPressInputValueX = CanConfiguration::Instance().SignalParsers()["NaviBtnPressInputValueX"];
        NaviBtnPressInputValueY = CanConfiguration::Instance().SignalParsers()["NaviBtnPressInputValueY"];
        RRMDisplayAVMOff = CanConfiguration::Instance().SignalParsers()["RRMDisplayAVMOff"];
        CalibrationReq = CanConfiguration::Instance().SignalParsers()["CalibrationReq"];
        IHU_12_CarMdlSetColor = CanConfiguration::Instance().SignalParsers()["IHU_12_CarMdlSetColor"];
        IHU_APAKeySts = CanConfiguration::Instance().SignalParsers()["IHU_APAKeySts"];
        AVMSwt = CanConfiguration::Instance().SignalParsers()["AVMSwt"];
        TouchEvt = CanConfiguration::Instance().SignalParsers()["TouchEvt"];
    }

    void Parser(uint8_t* payload){
        NaviBtnPressInputValueX.Parser(payload);
        NaviBtnPressInputValueY.Parser(payload);
        RRMDisplayAVMOff.Parser(payload);
        CalibrationReq.Parser(payload);
        IHU_12_CarMdlSetColor.Parser(payload);
        IHU_APAKeySts.Parser(payload);
        AVMSwt.Parser(payload);
        TouchEvt.Parser(payload);
    }

    void CanParser2CanStruct_IHU_12_MSG(IHU_12_MSG& msg) {
        double factor;
        double offset;
        factor = NaviBtnPressInputValueX.factor;
        offset = NaviBtnPressInputValueX.offset;
        msg.NaviBtnPressInputValueX = *reinterpret_cast<std::decay<decltype(msg.NaviBtnPressInputValueX)>::type*>(&NaviBtnPressInputValueX.signal);
        msg.NaviBtnPressInputValueX = msg.NaviBtnPressInputValueX * factor + offset;
        factor = NaviBtnPressInputValueY.factor;
        offset = NaviBtnPressInputValueY.offset;
        msg.NaviBtnPressInputValueY = *reinterpret_cast<std::decay<decltype(msg.NaviBtnPressInputValueY)>::type*>(&NaviBtnPressInputValueY.signal);
        msg.NaviBtnPressInputValueY = msg.NaviBtnPressInputValueY * factor + offset;
        factor = RRMDisplayAVMOff.factor;
        offset = RRMDisplayAVMOff.offset;
        msg.RRMDisplayAVMOff = *reinterpret_cast<std::decay<decltype(msg.RRMDisplayAVMOff)>::type*>(&RRMDisplayAVMOff.signal);
        msg.RRMDisplayAVMOff = msg.RRMDisplayAVMOff * factor + offset;
        factor = CalibrationReq.factor;
        offset = CalibrationReq.offset;
        msg.CalibrationReq = *reinterpret_cast<std::decay<decltype(msg.CalibrationReq)>::type*>(&CalibrationReq.signal);
        msg.CalibrationReq = msg.CalibrationReq * factor + offset;
        factor = IHU_12_CarMdlSetColor.factor;
        offset = IHU_12_CarMdlSetColor.offset;
        msg.IHU_12_CarMdlSetColor = *reinterpret_cast<std::decay<decltype(msg.IHU_12_CarMdlSetColor)>::type*>(&IHU_12_CarMdlSetColor.signal);
        msg.IHU_12_CarMdlSetColor = msg.IHU_12_CarMdlSetColor * factor + offset;
        factor = IHU_APAKeySts.factor;
        offset = IHU_APAKeySts.offset;
        msg.IHU_APAKeySts = *reinterpret_cast<std::decay<decltype(msg.IHU_APAKeySts)>::type*>(&IHU_APAKeySts.signal);
        msg.IHU_APAKeySts = msg.IHU_APAKeySts * factor + offset;
        factor = AVMSwt.factor;
        offset = AVMSwt.offset;
        msg.AVMSwt = *reinterpret_cast<std::decay<decltype(msg.AVMSwt)>::type*>(&AVMSwt.signal);
        msg.AVMSwt = msg.AVMSwt * factor + offset;
        factor = TouchEvt.factor;
        offset = TouchEvt.offset;
        msg.TouchEvt = *reinterpret_cast<std::decay<decltype(msg.TouchEvt)>::type*>(&TouchEvt.signal);
        msg.TouchEvt = msg.TouchEvt * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_12_MSG can_struct;
        CanParser2CanStruct_IHU_12_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_12_MSGMsg>();
        Struct2Proto_IHU_12_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_12") != nullptr) {
            DFHLOG_I("ihu_12");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_12")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_12");
            return false;
         }
    }
};

struct IHU_14_Parser {
    SignalParser LPN_Info1;

    SignalParser LPN_Info2;

    SignalParser LPN_Info3;

    SignalParser LPN_Info4;

    SignalParser LPN_Info5;

    SignalParser LPN_Info6;

    SignalParser LPN_Info7;

    SignalParser LPN_Info8;

    IHU_14_Parser() {
        LPN_Info1 = CanConfiguration::Instance().SignalParsers()["LPN_Info1"];
        LPN_Info2 = CanConfiguration::Instance().SignalParsers()["LPN_Info2"];
        LPN_Info3 = CanConfiguration::Instance().SignalParsers()["LPN_Info3"];
        LPN_Info4 = CanConfiguration::Instance().SignalParsers()["LPN_Info4"];
        LPN_Info5 = CanConfiguration::Instance().SignalParsers()["LPN_Info5"];
        LPN_Info6 = CanConfiguration::Instance().SignalParsers()["LPN_Info6"];
        LPN_Info7 = CanConfiguration::Instance().SignalParsers()["LPN_Info7"];
        LPN_Info8 = CanConfiguration::Instance().SignalParsers()["LPN_Info8"];
    }

    void Parser(uint8_t* payload){
        LPN_Info1.Parser(payload);
        LPN_Info2.Parser(payload);
        LPN_Info3.Parser(payload);
        LPN_Info4.Parser(payload);
        LPN_Info5.Parser(payload);
        LPN_Info6.Parser(payload);
        LPN_Info7.Parser(payload);
        LPN_Info8.Parser(payload);
    }

    void CanParser2CanStruct_IHU_14_MSG(IHU_14_MSG& msg) {
        double factor;
        double offset;
        factor = LPN_Info1.factor;
        offset = LPN_Info1.offset;
        msg.LPN_Info1 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info1)>::type*>(&LPN_Info1.signal);
        msg.LPN_Info1 = msg.LPN_Info1 * factor + offset;
        factor = LPN_Info2.factor;
        offset = LPN_Info2.offset;
        msg.LPN_Info2 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info2)>::type*>(&LPN_Info2.signal);
        msg.LPN_Info2 = msg.LPN_Info2 * factor + offset;
        factor = LPN_Info3.factor;
        offset = LPN_Info3.offset;
        msg.LPN_Info3 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info3)>::type*>(&LPN_Info3.signal);
        msg.LPN_Info3 = msg.LPN_Info3 * factor + offset;
        factor = LPN_Info4.factor;
        offset = LPN_Info4.offset;
        msg.LPN_Info4 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info4)>::type*>(&LPN_Info4.signal);
        msg.LPN_Info4 = msg.LPN_Info4 * factor + offset;
        factor = LPN_Info5.factor;
        offset = LPN_Info5.offset;
        msg.LPN_Info5 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info5)>::type*>(&LPN_Info5.signal);
        msg.LPN_Info5 = msg.LPN_Info5 * factor + offset;
        factor = LPN_Info6.factor;
        offset = LPN_Info6.offset;
        msg.LPN_Info6 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info6)>::type*>(&LPN_Info6.signal);
        msg.LPN_Info6 = msg.LPN_Info6 * factor + offset;
        factor = LPN_Info7.factor;
        offset = LPN_Info7.offset;
        msg.LPN_Info7 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info7)>::type*>(&LPN_Info7.signal);
        msg.LPN_Info7 = msg.LPN_Info7 * factor + offset;
        factor = LPN_Info8.factor;
        offset = LPN_Info8.offset;
        msg.LPN_Info8 = *reinterpret_cast<std::decay<decltype(msg.LPN_Info8)>::type*>(&LPN_Info8.signal);
        msg.LPN_Info8 = msg.LPN_Info8 * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_14_MSG can_struct;
        CanParser2CanStruct_IHU_14_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_14_MSGMsg>();
        Struct2Proto_IHU_14_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_14") != nullptr) {
            DFHLOG_I("ihu_14");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_14")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_14");
            return false;
         }
    }
};

struct IHU_29_Parser {
    SignalParser SLWFONOFFSet;

    SignalParser SLASpdlimitWarningAudSWSet;

    SignalParser IHU_29_SLAMode;

    SignalParser IHU_29_HPASet;

    SignalParser IHU_29_SpeedLmtNmberAb;

    SignalParser IHU_29_SpeedLmtNmberE;

    SignalParser IHU_29_VoiceReminder;

    SignalParser IHU_29_APAPrkgNr;

    SignalParser IHU_29_VoiceCtrldPrkgCmd;

    IHU_29_Parser() {
        SLWFONOFFSet = CanConfiguration::Instance().SignalParsers()["SLWFONOFFSet"];
        SLASpdlimitWarningAudSWSet = CanConfiguration::Instance().SignalParsers()["SLASpdlimitWarningAudSWSet"];
        IHU_29_SLAMode = CanConfiguration::Instance().SignalParsers()["IHU_29_SLAMode"];
        IHU_29_HPASet = CanConfiguration::Instance().SignalParsers()["IHU_29_HPASet"];
        IHU_29_SpeedLmtNmberAb = CanConfiguration::Instance().SignalParsers()["IHU_29_SpeedLmtNmberAb"];
        IHU_29_SpeedLmtNmberE = CanConfiguration::Instance().SignalParsers()["IHU_29_SpeedLmtNmberE"];
        IHU_29_VoiceReminder = CanConfiguration::Instance().SignalParsers()["IHU_29_VoiceReminder"];
        IHU_29_APAPrkgNr = CanConfiguration::Instance().SignalParsers()["IHU_29_APAPrkgNr"];
        IHU_29_VoiceCtrldPrkgCmd = CanConfiguration::Instance().SignalParsers()["IHU_29_VoiceCtrldPrkgCmd"];
    }

    void Parser(uint8_t* payload){
        SLWFONOFFSet.Parser(payload);
        SLASpdlimitWarningAudSWSet.Parser(payload);
        IHU_29_SLAMode.Parser(payload);
        IHU_29_HPASet.Parser(payload);
        IHU_29_SpeedLmtNmberAb.Parser(payload);
        IHU_29_SpeedLmtNmberE.Parser(payload);
        IHU_29_VoiceReminder.Parser(payload);
        IHU_29_APAPrkgNr.Parser(payload);
        IHU_29_VoiceCtrldPrkgCmd.Parser(payload);
    }

    void CanParser2CanStruct_IHU_29_MSG(IHU_29_MSG& msg) {
        double factor;
        double offset;
        factor = SLWFONOFFSet.factor;
        offset = SLWFONOFFSet.offset;
        msg.SLWFONOFFSet = *reinterpret_cast<std::decay<decltype(msg.SLWFONOFFSet)>::type*>(&SLWFONOFFSet.signal);
        msg.SLWFONOFFSet = msg.SLWFONOFFSet * factor + offset;
        factor = SLASpdlimitWarningAudSWSet.factor;
        offset = SLASpdlimitWarningAudSWSet.offset;
        msg.SLASpdlimitWarningAudSWSet = *reinterpret_cast<std::decay<decltype(msg.SLASpdlimitWarningAudSWSet)>::type*>(&SLASpdlimitWarningAudSWSet.signal);
        msg.SLASpdlimitWarningAudSWSet = msg.SLASpdlimitWarningAudSWSet * factor + offset;
        factor = IHU_29_SLAMode.factor;
        offset = IHU_29_SLAMode.offset;
        msg.IHU_29_SLAMode = *reinterpret_cast<std::decay<decltype(msg.IHU_29_SLAMode)>::type*>(&IHU_29_SLAMode.signal);
        msg.IHU_29_SLAMode = msg.IHU_29_SLAMode * factor + offset;
        factor = IHU_29_HPASet.factor;
        offset = IHU_29_HPASet.offset;
        msg.IHU_29_HPASet = *reinterpret_cast<std::decay<decltype(msg.IHU_29_HPASet)>::type*>(&IHU_29_HPASet.signal);
        msg.IHU_29_HPASet = msg.IHU_29_HPASet * factor + offset;
        factor = IHU_29_SpeedLmtNmberAb.factor;
        offset = IHU_29_SpeedLmtNmberAb.offset;
        msg.IHU_29_SpeedLmtNmberAb = *reinterpret_cast<std::decay<decltype(msg.IHU_29_SpeedLmtNmberAb)>::type*>(&IHU_29_SpeedLmtNmberAb.signal);
        msg.IHU_29_SpeedLmtNmberAb = msg.IHU_29_SpeedLmtNmberAb * factor + offset;
        factor = IHU_29_SpeedLmtNmberE.factor;
        offset = IHU_29_SpeedLmtNmberE.offset;
        msg.IHU_29_SpeedLmtNmberE = *reinterpret_cast<std::decay<decltype(msg.IHU_29_SpeedLmtNmberE)>::type*>(&IHU_29_SpeedLmtNmberE.signal);
        msg.IHU_29_SpeedLmtNmberE = msg.IHU_29_SpeedLmtNmberE * factor + offset;
        factor = IHU_29_VoiceReminder.factor;
        offset = IHU_29_VoiceReminder.offset;
        msg.IHU_29_VoiceReminder = *reinterpret_cast<std::decay<decltype(msg.IHU_29_VoiceReminder)>::type*>(&IHU_29_VoiceReminder.signal);
        msg.IHU_29_VoiceReminder = msg.IHU_29_VoiceReminder * factor + offset;
        factor = IHU_29_APAPrkgNr.factor;
        offset = IHU_29_APAPrkgNr.offset;
        msg.IHU_29_APAPrkgNr = *reinterpret_cast<std::decay<decltype(msg.IHU_29_APAPrkgNr)>::type*>(&IHU_29_APAPrkgNr.signal);
        msg.IHU_29_APAPrkgNr = msg.IHU_29_APAPrkgNr * factor + offset;
        factor = IHU_29_VoiceCtrldPrkgCmd.factor;
        offset = IHU_29_VoiceCtrldPrkgCmd.offset;
        msg.IHU_29_VoiceCtrldPrkgCmd = *reinterpret_cast<std::decay<decltype(msg.IHU_29_VoiceCtrldPrkgCmd)>::type*>(&IHU_29_VoiceCtrldPrkgCmd.signal);
        msg.IHU_29_VoiceCtrldPrkgCmd = msg.IHU_29_VoiceCtrldPrkgCmd * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        IHU_29_MSG can_struct;
        CanParser2CanStruct_IHU_29_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::IHU_29_MSGMsg>();
        Struct2Proto_IHU_29_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("ihu_29") != nullptr) {
            DFHLOG_I("ihu_29");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("ihu_29")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port ihu_29");
            return false;
         }
    }
};

struct OBC_3_Parser {
    SignalParser OBC_3_MessageCounter;

    SignalParser OBC_3_CRC;

    SignalParser OBC_CC_ConnectSts;

    OBC_3_Parser() {
        OBC_3_MessageCounter = CanConfiguration::Instance().SignalParsers()["OBC_3_MessageCounter"];
        OBC_3_CRC = CanConfiguration::Instance().SignalParsers()["OBC_3_CRC"];
        OBC_CC_ConnectSts = CanConfiguration::Instance().SignalParsers()["OBC_CC_ConnectSts"];
    }

    void Parser(uint8_t* payload){
        OBC_3_MessageCounter.Parser(payload);
        OBC_3_CRC.Parser(payload);
        OBC_CC_ConnectSts.Parser(payload);
    }

    void CanParser2CanStruct_OBC_3_MSG(OBC_3_MSG& msg) {
        double factor;
        double offset;
        factor = OBC_3_MessageCounter.factor;
        offset = OBC_3_MessageCounter.offset;
        msg.OBC_3_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.OBC_3_MessageCounter)>::type*>(&OBC_3_MessageCounter.signal);
        msg.OBC_3_MessageCounter = msg.OBC_3_MessageCounter * factor + offset;
        factor = OBC_3_CRC.factor;
        offset = OBC_3_CRC.offset;
        msg.OBC_3_CRC = *reinterpret_cast<std::decay<decltype(msg.OBC_3_CRC)>::type*>(&OBC_3_CRC.signal);
        msg.OBC_3_CRC = msg.OBC_3_CRC * factor + offset;
        factor = OBC_CC_ConnectSts.factor;
        offset = OBC_CC_ConnectSts.offset;
        msg.OBC_CC_ConnectSts = *reinterpret_cast<std::decay<decltype(msg.OBC_CC_ConnectSts)>::type*>(&OBC_CC_ConnectSts.signal);
        msg.OBC_CC_ConnectSts = msg.OBC_CC_ConnectSts * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        OBC_3_MSG can_struct;
        CanParser2CanStruct_OBC_3_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::OBC_3_MSGMsg>();
        Struct2Proto_OBC_3_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("obc_3") != nullptr) {
            DFHLOG_I("obc_3");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("obc_3")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port obc_3");
            return false;
         }
    }
};

struct YAS_1_Parser {
    SignalParser YAS_1_MessageCounter;

    SignalParser YAS_CalibrationSts;

    SignalParser YawrateSigValidData;

    SignalParser LateralAccelerationSigValidData;

    SignalParser LateralAcceleration;

    SignalParser YawRate;

    SignalParser YAS_1_Checksum;

    YAS_1_Parser() {
        YAS_1_MessageCounter = CanConfiguration::Instance().SignalParsers()["YAS_1_MessageCounter"];
        YAS_CalibrationSts = CanConfiguration::Instance().SignalParsers()["YAS_CalibrationSts"];
        YawrateSigValidData = CanConfiguration::Instance().SignalParsers()["YawrateSigValidData"];
        LateralAccelerationSigValidData = CanConfiguration::Instance().SignalParsers()["LateralAccelerationSigValidData"];
        LateralAcceleration = CanConfiguration::Instance().SignalParsers()["LateralAcceleration"];
        YawRate = CanConfiguration::Instance().SignalParsers()["YawRate"];
        YAS_1_Checksum = CanConfiguration::Instance().SignalParsers()["YAS_1_Checksum"];
    }

    void Parser(uint8_t* payload){
        YAS_1_MessageCounter.Parser(payload);
        YAS_CalibrationSts.Parser(payload);
        YawrateSigValidData.Parser(payload);
        LateralAccelerationSigValidData.Parser(payload);
        LateralAcceleration.Parser(payload);
        YawRate.Parser(payload);
        YAS_1_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_YAS_1_MSG(YAS_1_MSG& msg) {
        double factor;
        double offset;
        factor = YAS_1_MessageCounter.factor;
        offset = YAS_1_MessageCounter.offset;
        msg.YAS_1_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.YAS_1_MessageCounter)>::type*>(&YAS_1_MessageCounter.signal);
        msg.YAS_1_MessageCounter = msg.YAS_1_MessageCounter * factor + offset;
        factor = YAS_CalibrationSts.factor;
        offset = YAS_CalibrationSts.offset;
        msg.YAS_CalibrationSts = *reinterpret_cast<std::decay<decltype(msg.YAS_CalibrationSts)>::type*>(&YAS_CalibrationSts.signal);
        msg.YAS_CalibrationSts = msg.YAS_CalibrationSts * factor + offset;
        factor = YawrateSigValidData.factor;
        offset = YawrateSigValidData.offset;
        msg.YawrateSigValidData = *reinterpret_cast<std::decay<decltype(msg.YawrateSigValidData)>::type*>(&YawrateSigValidData.signal);
        msg.YawrateSigValidData = msg.YawrateSigValidData * factor + offset;
        factor = LateralAccelerationSigValidData.factor;
        offset = LateralAccelerationSigValidData.offset;
        msg.LateralAccelerationSigValidData = *reinterpret_cast<std::decay<decltype(msg.LateralAccelerationSigValidData)>::type*>(&LateralAccelerationSigValidData.signal);
        msg.LateralAccelerationSigValidData = msg.LateralAccelerationSigValidData * factor + offset;
        factor = LateralAcceleration.factor;
        offset = LateralAcceleration.offset;
        msg.LateralAcceleration = *reinterpret_cast<std::decay<decltype(msg.LateralAcceleration)>::type*>(&LateralAcceleration.signal);
        msg.LateralAcceleration = msg.LateralAcceleration * factor + offset;
        factor = YawRate.factor;
        offset = YawRate.offset;
        msg.YawRate = *reinterpret_cast<std::decay<decltype(msg.YawRate)>::type*>(&YawRate.signal);
        msg.YawRate = msg.YawRate * factor + offset;
        factor = YAS_1_Checksum.factor;
        offset = YAS_1_Checksum.offset;
        msg.YAS_1_Checksum = *reinterpret_cast<std::decay<decltype(msg.YAS_1_Checksum)>::type*>(&YAS_1_Checksum.signal);
        msg.YAS_1_Checksum = msg.YAS_1_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        YAS_1_MSG can_struct;
        CanParser2CanStruct_YAS_1_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::YAS_1_MSGMsg>();
        Struct2Proto_YAS_1_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("yas_1") != nullptr) {
            DFHLOG_I("yas_1");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("yas_1")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port yas_1");
            return false;
         }
    }
};

struct YAS_2_Parser {
    SignalParser YAS_2_MessageCounter;

    SignalParser LongitudinalAccelerationSigValid;

    SignalParser LongitudinalAcceleration;

    SignalParser YAS_2_Checksum;

    YAS_2_Parser() {
        YAS_2_MessageCounter = CanConfiguration::Instance().SignalParsers()["YAS_2_MessageCounter"];
        LongitudinalAccelerationSigValid = CanConfiguration::Instance().SignalParsers()["LongitudinalAccelerationSigValid"];
        LongitudinalAcceleration = CanConfiguration::Instance().SignalParsers()["LongitudinalAcceleration"];
        YAS_2_Checksum = CanConfiguration::Instance().SignalParsers()["YAS_2_Checksum"];
    }

    void Parser(uint8_t* payload){
        YAS_2_MessageCounter.Parser(payload);
        LongitudinalAccelerationSigValid.Parser(payload);
        LongitudinalAcceleration.Parser(payload);
        YAS_2_Checksum.Parser(payload);
    }

    void CanParser2CanStruct_YAS_2_MSG(YAS_2_MSG& msg) {
        double factor;
        double offset;
        factor = YAS_2_MessageCounter.factor;
        offset = YAS_2_MessageCounter.offset;
        msg.YAS_2_MessageCounter = *reinterpret_cast<std::decay<decltype(msg.YAS_2_MessageCounter)>::type*>(&YAS_2_MessageCounter.signal);
        msg.YAS_2_MessageCounter = msg.YAS_2_MessageCounter * factor + offset;
        factor = LongitudinalAccelerationSigValid.factor;
        offset = LongitudinalAccelerationSigValid.offset;
        msg.LongitudinalAccelerationSigValid = *reinterpret_cast<std::decay<decltype(msg.LongitudinalAccelerationSigValid)>::type*>(&LongitudinalAccelerationSigValid.signal);
        msg.LongitudinalAccelerationSigValid = msg.LongitudinalAccelerationSigValid * factor + offset;
        factor = LongitudinalAcceleration.factor;
        offset = LongitudinalAcceleration.offset;
        msg.LongitudinalAcceleration = *reinterpret_cast<std::decay<decltype(msg.LongitudinalAcceleration)>::type*>(&LongitudinalAcceleration.signal);
        msg.LongitudinalAcceleration = msg.LongitudinalAcceleration * factor + offset;
        factor = YAS_2_Checksum.factor;
        offset = YAS_2_Checksum.offset;
        msg.YAS_2_Checksum = *reinterpret_cast<std::decay<decltype(msg.YAS_2_Checksum)>::type*>(&YAS_2_Checksum.signal);
        msg.YAS_2_Checksum = msg.YAS_2_Checksum * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        YAS_2_MSG can_struct;
        CanParser2CanStruct_YAS_2_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::YAS_2_MSGMsg>();
        Struct2Proto_YAS_2_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("yas_2") != nullptr) {
            DFHLOG_I("yas_2");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("yas_2")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port yas_2");
            return false;
         }
    }
};

struct XCP_FCM_REQ_Parser {
    SignalParser XCP_FCM_REQ;

    XCP_FCM_REQ_Parser() {
        XCP_FCM_REQ = CanConfiguration::Instance().SignalParsers()["XCP_FCM_REQ"];
    }

    void Parser(uint8_t* payload){
        XCP_FCM_REQ.Parser(payload);
    }

    void CanParser2CanStruct_XCP_FCM_REQ_MSG(XCP_FCM_REQ_MSG& msg) {
        double factor;
        double offset;
        factor = XCP_FCM_REQ.factor;
        offset = XCP_FCM_REQ.offset;
        msg.XCP_FCM_REQ = *reinterpret_cast<std::decay<decltype(msg.XCP_FCM_REQ)>::type*>(&XCP_FCM_REQ.signal);
        msg.XCP_FCM_REQ = msg.XCP_FCM_REQ * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        XCP_FCM_REQ_MSG can_struct;
        CanParser2CanStruct_XCP_FCM_REQ_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::XCP_FCM_REQ_MSGMsg>();
        Struct2Proto_XCP_FCM_REQ_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("xcp_fcm_req") != nullptr) {
            DFHLOG_I("xcp_fcm_req");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("xcp_fcm_req")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port xcp_fcm_req");
            return false;
         }
    }
};

struct Diag_IDCU_REQ_Parser {
    SignalParser Diag_IDCU_REQ;

    Diag_IDCU_REQ_Parser() {
        Diag_IDCU_REQ = CanConfiguration::Instance().SignalParsers()["Diag_IDCU_REQ"];
    }

    void Parser(uint8_t* payload){
        Diag_IDCU_REQ.Parser(payload);
    }

    void CanParser2CanStruct_Diag_IDCU_REQ_MSG(Diag_IDCU_REQ_MSG& msg) {
        double factor;
        double offset;
        factor = Diag_IDCU_REQ.factor;
        offset = Diag_IDCU_REQ.offset;
        msg.Diag_IDCU_REQ = *reinterpret_cast<std::decay<decltype(msg.Diag_IDCU_REQ)>::type*>(&Diag_IDCU_REQ.signal);
        msg.Diag_IDCU_REQ = msg.Diag_IDCU_REQ * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        Diag_IDCU_REQ_MSG can_struct;
        CanParser2CanStruct_Diag_IDCU_REQ_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::Diag_IDCU_REQ_MSGMsg>();
        Struct2Proto_Diag_IDCU_REQ_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("diag_idcu_req") != nullptr) {
            DFHLOG_I("diag_idcu_req");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("diag_idcu_req")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port diag_idcu_req");
            return false;
         }
    }
};

struct DIAG_OBD_REQ_Broadcast_Parser {
    SignalParser Diag_Functional_REQ;

    DIAG_OBD_REQ_Broadcast_Parser() {
        Diag_Functional_REQ = CanConfiguration::Instance().SignalParsers()["Diag_Functional_REQ"];
    }

    void Parser(uint8_t* payload){
        Diag_Functional_REQ.Parser(payload);
    }

    void CanParser2CanStruct_DIAG_OBD_REQ_Broadcast_MSG(DIAG_OBD_REQ_Broadcast_MSG& msg) {
        double factor;
        double offset;
        factor = Diag_Functional_REQ.factor;
        offset = Diag_Functional_REQ.offset;
        msg.Diag_Functional_REQ = *reinterpret_cast<std::decay<decltype(msg.Diag_Functional_REQ)>::type*>(&Diag_Functional_REQ.signal);
        msg.Diag_Functional_REQ = msg.Diag_Functional_REQ * factor + offset;
    }

    bool Process(hobot::dataflow::spNoResourceProc& proc, uint8_t* payload){
        Parser(payload);
        DIAG_OBD_REQ_Broadcast_MSG can_struct;
        CanParser2CanStruct_DIAG_OBD_REQ_Broadcast_MSG(can_struct);
        auto msg = std::make_shared<zpilot::candata::DIAG_OBD_REQ_Broadcast_MSGMsg>();
        Struct2Proto_DIAG_OBD_REQ_Broadcast_MSG(can_struct, &msg->proto);
        Proto2Json::toJson(msg->proto);
        if (proc->GetOutputPort("diag_obd_req_broadcast") != nullptr) {
            DFHLOG_I("diag_obd_req_broadcast");
            const auto time_update = GetTimeStamp();
            msg->SetGenTimestamp(time_update);
            msg->SetDoneTimestamp(time_update);
            return proc->GetOutputPort("diag_obd_req_broadcast")->Send(msg) == 0;
         }
         else {
            DFHLOG_E("no such port diag_obd_req_broadcast");
            return false;
         }
    }
};

